diff --git a/test/format/format.h b/test/format/format.h
index 7f5230709..fe1e4e45b 100644
--- a/test/format/format.h
+++ b/test/format/format.h
@@ -122,6 +122,7 @@ typedef struct {
     RWLOCK ts_lock;
 
     uint64_t timestamp; /* Counter for timestamps */
+    uint64_t stable_timestamp; /* Last timestamp used for stable */
 
     uint64_t truncate_cnt; /* Counter for truncation */
 
@@ -381,6 +382,7 @@ void path_setup(const char *);
 void set_alarm(u_int);
 void set_core_off(void);
 void snap_init(TINFO *, uint64_t, bool);
+bool snap_mod_dup(TINFO *);
 void snap_repeat_single(WT_CURSOR *, TINFO *);
 int snap_repeat_txn(WT_CURSOR *, TINFO *);
 void snap_repeat_update(TINFO *, bool);
diff --git a/test/format/ops.c b/test/format/ops.c
index 82aa22d5f..4ab540aaf 100644
--- a/test/format/ops.c
+++ b/test/format/ops.c
@@ -715,6 +715,12 @@ ops(void *arg)
         /* Select a row. */
         tinfo->keyno = mmrand(&tinfo->rnd, 1, (u_int)g.rows);
 
+        /* XXX: temporary change to never modify over an existing modification. WT-6185. */
+        if (op != READ && intxn && iso_config == ISOLATION_SNAPSHOT && snap_mod_dup(tinfo)) {
+            //fprintf(stderr, "\ndup!\n");
+            op = READ;
+        }
+
         /*
          * Inserts, removes and updates can be done following a cursor set-key, or based on a cursor
          * position taken from a previous search. If not already doing a read, position the cursor
diff --git a/test/format/snap.c b/test/format/snap.c
index 15c82a649..0ec82d755 100644
--- a/test/format/snap.c
+++ b/test/format/snap.c
@@ -44,6 +44,27 @@ snap_init(TINFO *tinfo, uint64_t read_ts, bool repeatable_reads)
     tinfo->repeatable_wrap = false;
 }
 
+/*
+ * snap_mod_dup --
+ *     Return true if the proposed operation matches an existing modify operation in
+ * the same transaction.
+ */
+bool
+snap_mod_dup(TINFO *tinfo)
+{
+    SNAP_OPS *snap;
+
+    for (snap = tinfo->snap_first; snap != tinfo->snap;) {
+        if (tinfo->keyno == snap->keyno && snap->op == MODIFY)
+            return (true);
+        /* Wrap at the end of the circular buffer. */
+        if (++snap >= &tinfo->snap_list[WT_ELEMENTS(tinfo->snap_list)])
+            snap = tinfo->snap_list;
+    }
+    return (false);
+}
+
+
 /*
  * snap_track --
  *     Add a single snapshot isolation returned value to the list.
diff --git a/test/format/t.c b/test/format/t.c
index 65eb53eb2..867dd79d7 100644
--- a/test/format/t.c
+++ b/test/format/t.c
@@ -288,6 +288,10 @@ main(int argc, char *argv[])
         /* Copy out the run's statistics. */
         TIMED_MAJOR_OP(wts_stats());
 
+        track("rollback_to_stable", 0ULL, NULL);
+        tracemsg("%-10s ts=%" PRIu64, "rts", g.stable_timestamp);
+        g.wts_conn->rollback_to_stable(g.wts_conn, NULL);
+
         /*
          * Verify the objects. Verify closes the underlying handle and discards the statistics, read
          * them first.
diff --git a/test/format/util.c b/test/format/util.c
index c8be232e1..0b2d074f1 100644
--- a/test/format/util.c
+++ b/test/format/util.c
@@ -166,14 +166,13 @@ void
 timestamp_once(WT_SESSION *session)
 {
     static const char *oldest_timestamp_str = "oldest_timestamp=";
+    static const char *stable_timestamp_str = "stable_timestamp=";
     WT_CONNECTION *conn;
     WT_DECL_RET;
-    char buf[WT_TS_HEX_STRING_SIZE + 64];
+    char buf[WT_TS_HEX_STRING_SIZE * 2 + 64], tsbuf[WT_TS_HEX_STRING_SIZE + 1];
 
     conn = g.wts_conn;
 
-    testutil_check(__wt_snprintf(buf, sizeof(buf), "%s", oldest_timestamp_str));
-
     /*
      * Lock out transaction timestamp operations. The lock acts as a barrier ensuring we've checked
      * if the workers have finished, we don't want that line reordered. We can also be called from
@@ -183,7 +182,10 @@ timestamp_once(WT_SESSION *session)
     if (LOCK_INITIALIZED(&g.ts_lock))
         lock_writelock(session, &g.ts_lock);
 
-    ret = conn->query_timestamp(conn, buf + strlen(oldest_timestamp_str), "get=all_durable");
+    ret = conn->query_timestamp(conn, tsbuf, "get=all_durable");
+    testutil_check(__wt_snprintf(buf, sizeof(buf), "%s%s,%s%s", oldest_timestamp_str, tsbuf,
+        stable_timestamp_str, tsbuf));
+
     testutil_assert(ret == 0 || ret == WT_NOTFOUND);
     if (ret == 0)
         testutil_check(conn->set_timestamp(conn, buf));
@@ -213,15 +215,15 @@ timestamp(void *arg)
     done = false;
     do {
         /*
-         * Do a final bump of the oldest timestamp as part of shutting down the worker threads,
-         * otherwise recent operations can prevent verify from running.
+         * Don't do a final bump of the oldest timestamp as part of shutting down the worker threads,
+         * so that rollback_to_stable has something to do.
          */
         if (g.workers_finished)
             done = true;
-        else
+        else {
             random_sleep(&g.rnd, 15);
-
-        timestamp_once(session);
+            timestamp_once(session);
+        }
 
     } while (!done);
 
