diff --git a/src/txn/txn_recover.c b/src/txn/txn_recover.c
index fd230dab5..dd50d5a13 100644
--- a/src/txn/txn_recover.c
+++ b/src/txn/txn_recover.c
@@ -832,8 +832,7 @@ done:
      *    checkpoint happened. Anything updates newer than this timestamp must rollback.
      * 3. The history store file was found in the metadata.
      */
-    if (hs_exists && !F_ISSET(conn, WT_CONN_READONLY) &&
-      conn->txn_global.recovery_timestamp != WT_TS_NONE) {
+    if (hs_exists && !F_ISSET(conn, WT_CONN_READONLY)) {
         /* Start the eviction threads for rollback to stable if not already started. */
         if (!eviction_started) {
             WT_ERR(__wt_evict_create(session));
@@ -860,7 +859,11 @@ done:
          * stable.
          */
         conn->txn_global.stable_timestamp = conn->txn_global.recovery_timestamp;
-        conn->txn_global.has_stable_timestamp = true;
+
+        if (conn->txn_global.recovery_timestamp != WT_TS_NONE)
+            conn->txn_global.has_stable_timestamp = true;
+        else
+            conn->txn_global.has_stable_timestamp = false;
 
         __wt_verbose(session, WT_VERB_RTS,
           "Performing recovery rollback_to_stable with stable timestamp: %s and oldest timestamp: "
diff --git a/src/txn/txn_rollback_to_stable.c b/src/txn/txn_rollback_to_stable.c
index 479bedc84..5dc640bd8 100644
--- a/src/txn/txn_rollback_to_stable.c
+++ b/src/txn/txn_rollback_to_stable.c
@@ -967,17 +967,9 @@ __rollback_to_stable_btree(WT_SESSION_IMPL *session, wt_timestamp_t rollback_tim
 static int
 __rollback_to_stable_check(WT_SESSION_IMPL *session)
 {
-    WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
-    WT_TXN_GLOBAL *txn_global;
     bool txn_active;
 
-    conn = S2C(session);
-    txn_global = &conn->txn_global;
-
-    if (!txn_global->has_stable_timestamp)
-        WT_RET_MSG(session, EINVAL, "rollback_to_stable requires a stable timestamp");
-
     /*
      * Help the user comply with the requirement that there are no concurrent operations. Protect
      * against spurious conflicts with the sweep server: we exclude it from running concurrent with
@@ -1219,6 +1211,16 @@ __rollback_to_stable_btree_apply(WT_SESSION_IMPL *session)
             continue;
         WT_ERR(ret);
 
+        if (F_ISSET(S2C(session), WT_CONN_RECOVERING) && txn_global->stable_timestamp == WT_TS_NONE && max_durable_ts != WT_TS_NONE) {
+            //printf ("===== Skip RTS stable_timestamp == WT_TS_NONE && max_durable_ts != WT_TS_NONE ===== \n");
+            continue;
+        }
+
+        /*
+        if (F_ISSET(S2C(session), WT_CONN_RECOVERING))
+            printf ("===== Call RTS =====\n");
+        */
+       
         /*
          * The rollback operation should be performed on this file based on the following:
          * 1. The tree is modified.
diff --git a/test/suite/test_rollback_to_stable14.py b/test/suite/test_rollback_to_stable14.py
new file mode 100644
index 000000000..cdf1bf6f3
--- /dev/null
+++ b/test/suite/test_rollback_to_stable14.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+#
+# Public Domain 2014-2020 MongoDB, Inc.
+# Public Domain 2008-2014 WiredTiger, Inc.
+#
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+import time
+from helper import copy_wiredtiger_home
+import wiredtiger, wttest
+from wtdataset import SimpleDataSet
+from wiredtiger import stat
+from wtscenario import make_scenarios
+from test_rollback_to_stable01 import test_rollback_to_stable_base
+
+def timestamp_str(t):
+    return '%x' % t
+
+# test_rollback_to_stable14.py
+# Test that rollback to stable works without stable timestamp.
+class test_rollback_to_stable14(test_rollback_to_stable_base):
+    session_config = 'isolation=snapshot'
+
+    in_memory_values = [
+        ('no_inmem', dict(in_memory=False)),
+        ('inmem', dict(in_memory=True))
+    ]
+
+    scenarios = make_scenarios(in_memory_values)
+
+    def conn_config(self):
+        config = 'cache_size=50MB,statistics=(all)'
+        if self.in_memory:
+            config += ',in_memory=true'
+        else:
+            config += ',log=(enabled),in_memory=false'
+        return config
+
+    def test_rollback_to_stable(self):
+        nrows = 1000
+
+        # Create two tables without logging.
+        uri_1 = "table:rollback_to_stable14_1"
+        ds_1 = SimpleDataSet(
+            self, uri_1, 0, key_format="i", value_format="S", config='log=(enabled=false)')
+        ds_1.populate()
+
+        uri_2 = "table:rollback_to_stable14_2"
+        ds_2 = SimpleDataSet(
+            self, uri_2, 0, key_format="i", value_format="S", config='log=(enabled=false)')
+        ds_2.populate()
+
+        # Pin oldest to timestamp 1.
+        self.conn.set_timestamp('oldest_timestamp=' + timestamp_str(1))
+
+        valuea = "aaaaa" * 100
+        valueb = "bbbbb" * 100
+        valuec = "ccccc" * 100
+        valued = "ddddd" * 100
+        self.large_updates(uri_1, valuea, ds_1, nrows, 0)
+        self.check(valuea, uri_1, nrows, 0)
+
+        self.large_updates(uri_2, valuea, ds_2, nrows, 0)
+        self.check(valuea, uri_2, nrows, 0)
+
+        # Start a long running transaction and keep it open.
+        session_2 = self.conn.open_session()
+        session_2.begin_transaction('isolation=snapshot')
+
+        self.large_updates(uri_1, valueb, ds_1, nrows, 0)
+        self.check(valueb, uri_1, nrows, 0)
+
+        self.large_updates(uri_1, valuec, ds_1, nrows, 0)
+        self.check(valuec, uri_1, nrows, 0)
+
+        self.large_updates(uri_1, valued, ds_1, nrows, 0)
+        self.check(valued, uri_1, nrows, 0)
+
+        # Add updates to the another table.
+        self.large_updates(uri_2, valueb, ds_2, nrows, 0)
+        self.check(valueb, uri_2, nrows, 0)
+
+        self.large_updates(uri_2, valuec, ds_2, nrows, 0)
+        self.check(valuec, uri_2, nrows, 0)
+
+        self.large_updates(uri_2, valued, ds_2, nrows, 0)
+        self.check(valued, uri_2, nrows, 0)
+
+        # Checkpoint to ensure that all the data is flushed.
+        if not self.in_memory:
+            self.session.checkpoint()
+
+        # Clear all running transactions before rollback to stable.
+        session_2.commit_transaction()
+        session_2.close()
+
+        self.conn.rollback_to_stable()
+        self.check(valued, uri_1, nrows, 0)
+        self.check(valued, uri_2, nrows, 0)
+
+if __name__ == '__main__':
+    wttest.run()
