diff --git a/src/btree/bt_curnext.c b/src/btree/bt_curnext.c
index fa2db5a02e..7981dee358 100644
--- a/src/btree/bt_curnext.c
+++ b/src/btree/bt_curnext.c
@@ -991,6 +991,7 @@ err:
         F_SET(cbt, WT_CBT_ITERATE_RETRY_NEXT);
         break;
     default:
+        (void)__wt_log_printf(session, "BTCUR_NEXT_PREFIX ret %d", ret);
         WT_TRET(__cursor_reset(cbt));
     }
     F_CLR(cbt, WT_CBT_ITERATE_RETRY_PREV);
diff --git a/src/btree/bt_curprev.c b/src/btree/bt_curprev.c
index 8a6e08cadb..018c81c506 100644
--- a/src/btree/bt_curprev.c
+++ b/src/btree/bt_curprev.c
@@ -926,6 +926,7 @@ err:
         F_SET(cbt, WT_CBT_ITERATE_RETRY_PREV);
         break;
     default:
+        (void)__wt_log_printf(session, "BTCUR_PREV_PREFIX: ret %d cursor_reset", ret);
         WT_TRET(__cursor_reset(cbt));
     }
     F_CLR(cbt, WT_CBT_ITERATE_RETRY_NEXT);
diff --git a/src/btree/bt_cursor.c b/src/btree/bt_cursor.c
index 82c506757f..6749217fda 100644
--- a/src/btree/bt_cursor.c
+++ b/src/btree/bt_cursor.c
@@ -617,6 +617,7 @@ __wt_btcur_reset(WT_CURSOR_BTREE *cbt)
     cursor = &cbt->iface;
     session = CUR2S(cbt);
 
+    (void)__wt_log_printf(session, "BTCUR_RESET: called");
     WT_STAT_CONN_DATA_INCR(session, cursor_reset);
 
     F_CLR(cursor, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);
@@ -650,6 +651,7 @@ __wt_btcur_search_prepared(WT_CURSOR *cursor, WT_UPDATE **updp)
      * from the last operation. This also depends on the fact we're not setting the cursor's active
      * flag, this is really a special chunk of code and not to be modified without careful thought.
      */
+    (void)__wt_log_printf(CUR2S(cbt), "BTCUR_SEARCH_PREPARED: call cursor_reset");
     WT_RET(__cursor_reset(cbt));
 
     WT_RET(btree->type == BTREE_ROW ? __cursor_row_search(cbt, false, NULL, NULL) :
@@ -740,6 +742,7 @@ __wt_btcur_evict_reposition(WT_CURSOR_BTREE *cbt)
 
         WT_STAT_CONN_DATA_INCR(session, cursor_reposition);
         WT_ERR(__wt_cursor_localkey(cursor));
+        (void)__wt_log_printf(session, "BTCUR_EVICT_REPOS: call cursor_reset");
         WT_ERR(__cursor_reset(cbt));
         WT_WITHOUT_EVICT_REPOSITION(ret = __wt_btcur_search(cbt));
         WT_ERR(ret);
@@ -790,7 +793,14 @@ __wt_btcur_search(WT_CURSOR_BTREE *cbt)
      * (unlike other cursor functions), because we don't anticipate applications searching for a key
      * they currently have pinned.)
      */
+#if 0
     WT_ERR(__wt_cursor_localkey(cursor));
+#else
+    ret = __wt_cursor_localkey(cursor);
+    if (ret != 0)
+        (void)__wt_log_printf(session, "BT_SEARCH: cursor_localkey ret %d", ret);
+    WT_ERR(ret);
+#endif
     __cursor_novalue(cursor);
     __cursor_state_save(cursor, &state);
 
@@ -798,10 +808,19 @@ __wt_btcur_search(WT_CURSOR_BTREE *cbt)
      * Check that the provided search key is within bounds. If not, return WT_NOTFOUND and early
      * exit.
      */
+#if 0
     WT_ERR(__btcur_bounds_contains_key(
       session, cursor, &cursor->key, cursor->recno, &key_out_of_bounds, NULL));
+#else
+    ret = __btcur_bounds_contains_key(
+      session, cursor, &cursor->key, cursor->recno, &key_out_of_bounds, NULL);
+    if (ret != 0)
+        (void)__wt_log_printf(session, "BT_SEARCH: btcur_bounds_contains_key ret %d", ret);
+    WT_ERR(ret);
+#endif
     if (key_out_of_bounds) {
         WT_STAT_CONN_DATA_INCR(session, cursor_bounds_search_early_exit);
+        (void)__wt_log_printf(session, "BT_SEARCH: key out of bounds WT_NOTFOUND");
         WT_ERR(WT_NOTFOUND);
     }
 
@@ -813,28 +832,87 @@ __wt_btcur_search(WT_CURSOR_BTREE *cbt)
         __wt_txn_cursor_op(session);
 
         if (btree->type == BTREE_ROW)
+#if 0
             WT_ERR(__cursor_row_search(cbt, false, cbt->ref, &leaf_found));
-        else
+#else
+        {
+            ret = __cursor_row_search(cbt, false, cbt->ref, &leaf_found);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: pinned cursor_row_search ret %d", ret);
+            WT_ERR(ret);
+        }
+#endif
+            else
+#if 0
             WT_ERR(__cursor_col_search(cbt, cbt->ref, &leaf_found));
+#else
+        {
+            ret = __cursor_col_search(cbt, cbt->ref, &leaf_found);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: pinned cursor_col_search ret %d", ret);
+            WT_ERR(ret);
+        }
+#endif
 
-        if (leaf_found && cbt->compare == 0)
+              if (leaf_found && cbt->compare == 0)
+#if 0
             WT_ERR(__wt_cursor_valid(cbt, &valid, false));
+#else
+        {
+            ret = __wt_cursor_valid(cbt, &valid, false);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: pinned cursor_valid ret %d", ret);
+            WT_ERR(ret);
+        }
+#endif
     }
     if (!valid) {
+#if 0
         WT_ERR(__wt_cursor_func_init(cbt, true));
+#else
+        ret = __wt_cursor_func_init(cbt, true);
+        if (ret != 0)
+            (void)__wt_log_printf(session, "BT_SEARCH: NOT valid cursor_func_init  ret %d", ret);
+        WT_ERR(ret);
+#endif
 
+#if 0
         if (btree->type == BTREE_ROW)
             WT_ERR(__cursor_row_search(cbt, false, NULL, NULL));
         else
             WT_ERR(__cursor_col_search(cbt, NULL, NULL));
+#else
+        if (btree->type == BTREE_ROW) {
+            ret = __cursor_row_search(cbt, false, NULL, NULL);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: NOT valid row_search  ret %d", ret);
+            WT_ERR(ret);
+        } else {
+            ret = __cursor_col_search(cbt, NULL, NULL);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: NOT valid col_search  ret %d", ret);
+            WT_ERR(ret);
+        }
+#endif
 
         if (cbt->compare == 0)
+#if 0
             WT_ERR(__wt_cursor_valid(cbt, &valid, false));
+#else
+        {
+            ret = __wt_cursor_valid(cbt, &valid, false);
+            if (ret != 0)
+                (void)__wt_log_printf(session, "BT_SEARCH: NOT valid cursor_valid  ret %d", ret);
+            WT_ERR(ret);
+        }
+#endif
     }
 
     if (valid)
         ret = F_ISSET(cursor, WT_CURSTD_KEY_ONLY) ? __wt_key_return(cbt) :
                                                     __cursor_kv_return(cbt, cbt->upd_value);
+    if (ret != 0)
+        (void)__wt_log_printf(session, "BT_SEARCH: valid key/kv return ret %d", ret);
     else if (__cursor_fix_implicit(btree, cbt)) {
         /*
          * Creating a record past the end of the tree in a fixed-length column-store implicitly
@@ -847,29 +925,55 @@ __wt_btcur_search(WT_CURSOR_BTREE *cbt)
         F_CLR(cursor, WT_CURSTD_KEY_SET | WT_CURSTD_VALUE_SET);
         F_SET(cursor, WT_CURSTD_KEY_INT | WT_CURSTD_VALUE_INT);
     } else
+#if 0
+        ret = WT_NOTFOUND;
+#else
+    {
         ret = WT_NOTFOUND;
+        (void)__wt_log_printf(session, "BT_SEARCH: NOT valid nor implicit WT_NOTFOUND");
+    }
+#endif
 
-    /*
-     * The format test program does repeatable reads testing, and wants to dump the cursor page on
-     * failure. It sets up a callback for that purpose, and we pay a cache miss per search to make
-     * that work.
-     */
-    if (session->format_private != NULL && (ret == 0 || ret == WT_NOTFOUND))
+      /*
+       * The format test program does repeatable reads testing, and wants to dump the cursor page on
+       * failure. It sets up a callback for that purpose, and we pay a cache miss per search to make
+       * that work.
+       */
+      if (session->format_private != NULL && (ret == 0 || ret == WT_NOTFOUND))
         session->format_private(ret, session->format_private_arg);
 
 #ifdef HAVE_DIAGNOSTIC
     if (ret == 0)
+#if 0
         WT_ERR(__wt_cursor_key_order_init(cbt));
+#else
+    {
+        ret = __wt_cursor_key_order_init(cbt);
+        if (ret != 0)
+            (void)__wt_log_printf(session, "BT_SEARCH: END cursor_key_order_init ret %d", ret);
+        WT_ERR(ret);
+    }
+#endif
 #endif
 
-    if (ret == 0)
+        if (ret == 0)
+#if 0
         WT_ERR(__wt_btcur_evict_reposition(cbt));
+#else
+    {
+        ret = __wt_btcur_evict_reposition(cbt);
+        if (ret != 0)
+            (void)__wt_log_printf(session, "BT_SEARCH: END evict_reposition  ret %d", ret);
+        WT_ERR(ret);
+    }
+#endif
 
 err:
-    if (ret != 0) {
-        WT_TRET(__cursor_reset(cbt));
-        __cursor_state_restore(cursor, &state);
-    }
+            if (ret != 0) {
+                (void)__wt_log_printf(session, "BTCUR_SEARCH: ERR ret %d call cursor_reset", ret);
+                WT_TRET(__cursor_reset(cbt));
+                __cursor_state_restore(cursor, &state);
+            }
     return (ret);
 }
 
@@ -1118,6 +1222,7 @@ err:
          * and next loops. Those internally do reset the cursor but not when performing a prefix
          * search near.
          */
+        (void)__wt_log_printf(session, "BTCUR_SEARCH_NEAR: ERR ret %d call cursor_reset", ret);
         WT_TRET(__cursor_reset(cbt));
         __cursor_state_restore(cursor, &state);
     }
diff --git a/src/btree/bt_read.c b/src/btree/bt_read.c
index 77196a7175..503cf0aeca 100644
--- a/src/btree/bt_read.c
+++ b/src/btree/bt_read.c
@@ -337,6 +337,8 @@ read:
             stalled = true;
             break;
         case WT_REF_SPLIT:
+            (void)__wt_log_printf(session, "PAGE_IN_FUNC: %s WT_RESTART due to ref %p WT_REF_SPLIT",
+              session->dhandle->name, (void *)ref);
             return (WT_RESTART);
         case WT_REF_MEM:
             /*
diff --git a/src/btree/bt_ret.c b/src/btree/bt_ret.c
index 9ce60d727b..5081c68ca0 100644
--- a/src/btree/bt_ret.c
+++ b/src/btree/bt_ret.c
@@ -200,6 +200,8 @@ __read_page_cell_data_ref_kv(WT_SESSION_IMPL *session, WT_PAGE *page, WT_CELL_UN
     WT_RET(__wt_page_cell_data_ref_kv(session, page, unpack, buf));
     if (unpack->cell != NULL && __wt_cell_type_raw(unpack->cell) == WT_CELL_VALUE_OVFL_RM) {
         WT_STAT_CONN_DATA_INCR(session, txn_read_overflow_remove);
+        (void)__wt_log_printf(
+          session, "READ_PAGE_CELL: %s overflow removed value", session->dhandle->name);
         return (WT_RESTART);
     }
     return (0);
diff --git a/src/include/btree_inline.h b/src/include/btree_inline.h
index 881249edb1..ace946ebb1 100644
--- a/src/include/btree_inline.h
+++ b/src/include/btree_inline.h
@@ -2165,8 +2165,11 @@ __wt_page_swap_func(WT_SESSION_IMPL *session, WT_REF *held, WT_REF *want, uint32
      */
     if (LF_ISSET(WT_READ_NOTFOUND_OK) && ret == WT_NOTFOUND)
         return (WT_NOTFOUND);
-    if (LF_ISSET(WT_READ_RESTART_OK) && ret == WT_RESTART)
+    if (LF_ISSET(WT_READ_RESTART_OK) && ret == WT_RESTART) {
+        (void)__wt_log_printf(
+          session, "PAGE_SWAP: %s pagein func ret WT_RESTART", session->dhandle->name);
         return (WT_RESTART);
+    }
 
     /* Discard the original held page on either success or error. */
     acquired = ret == 0;
diff --git a/src/include/cursor_inline.h b/src/include/cursor_inline.h
index 126a942721..88f74d504c 100644
--- a/src/include/cursor_inline.h
+++ b/src/include/cursor_inline.h
@@ -411,8 +411,10 @@ __wt_cursor_func_init(WT_CURSOR_BTREE *cbt, bool reenter)
 
     session = CUR2S(cbt);
 
-    if (reenter)
+    if (reenter) {
+        (void)__wt_log_printf(session, "CUR_FUNC_INIT: call cursor_reset");
         WT_RET(__cursor_reset(cbt));
+    }
 
     /*
      * Any old insert position is now invalid. We rely on this being cleared to detect if a new
diff --git a/src/include/serial_inline.h b/src/include/serial_inline.h
index ced6d3f737..538ebb4f94 100644
--- a/src/include/serial_inline.h
+++ b/src/include/serial_inline.h
@@ -30,8 +30,11 @@ __insert_simple_func(
      */
     for (i = 0; i < skipdepth; i++) {
         WT_INSERT *old_ins = *ins_stack[i];
-        if (old_ins != new_ins->next[i] || !__wt_atomic_cas_ptr(ins_stack[i], old_ins, new_ins))
+        if (old_ins != new_ins->next[i] || !__wt_atomic_cas_ptr(ins_stack[i], old_ins, new_ins)) {
+            if (i == 0)
+                (void)__wt_log_printf(session, "INS_SIMPLE: %s WT_RESTART", session->dhandle->name);
             return (i == 0 ? WT_RESTART : 0);
+        }
     }
 
     return (0);
@@ -64,8 +67,11 @@ __insert_serial_func(WT_SESSION_IMPL *session, WT_INSERT_HEAD *ins_head, WT_INSE
      */
     for (i = 0; i < skipdepth; i++) {
         WT_INSERT *old_ins = *ins_stack[i];
-        if (old_ins != new_ins->next[i] || !__wt_atomic_cas_ptr(ins_stack[i], old_ins, new_ins))
+        if (old_ins != new_ins->next[i] || !__wt_atomic_cas_ptr(ins_stack[i], old_ins, new_ins)) {
+            if (i == 0)
+                (void)__wt_log_printf(session, "INS_SERIAL: %s WT_RESTART", session->dhandle->name);
             return (i == 0 ? WT_RESTART : 0);
+        }
         if (ins_head->tail[i] == NULL || ins_stack[i] == &ins_head->tail[i]->next[i])
             ins_head->tail[i] = new_ins;
     }
diff --git a/src/include/txn_inline.h b/src/include/txn_inline.h
index f6a75c9c78..823fac910f 100644
--- a/src/include/txn_inline.h
+++ b/src/include/txn_inline.h
@@ -1093,6 +1093,8 @@ retry:
              */
             ret = __wt_value_return_buf(cbt, cbt->ref, &cbt->upd_value->buf, &tw);
             if (ret == WT_RESTART) {
+                (void)__wt_log_printf(
+                  session, "TXN_READ: %s value_return_buf got WT_RESTART", session->dhandle->name);
                 read_onpage = false;
                 goto retry;
             } else
diff --git a/test/format/bulk.c b/test/format/bulk.c
index a88d3b3a9c..ad3d6fc934 100644
--- a/test/format/bulk.c
+++ b/test/format/bulk.c
@@ -95,7 +95,8 @@ table_load(TABLE *base, TABLE *table)
 
     testutil_check(__wt_snprintf(track_buf, sizeof(track_buf), "table %u %s load", table->id,
       base == NULL ? "bulk" : "mirror"));
-    trace_msg(session, "=============== %s bulk load start", table->uri);
+    trace_msg(session, "=============== %s bulk load start (%s)", table->uri,
+      base == NULL ? "bulk" : "mirror");
 
     /* Optionally open the base mirror. */
     base_cursor = NULL;
@@ -105,6 +106,8 @@ table_load(TABLE *base, TABLE *table)
     /* No bulk load with custom collators, insertion order won't match collation order. */
     is_bulk = TV(BTREE_REVERSE) == 0;
     wt_wrap_open_cursor(session, table->uri, is_bulk ? "bulk,append" : NULL, &cursor);
+    trace_msg(session, "=============== %s bulk load start open cursor (%s)", table->uri,
+      is_bulk ? "bulk,append" : "NULL");
 
     /* Set up the key/value buffers. */
     key_gen_init(&key);
diff --git a/test/format/t.c b/test/format/t.c
index 632a457d04..71576595b3 100644
--- a/test/format/t.c
+++ b/test/format/t.c
@@ -185,8 +185,12 @@ int
 main(int argc, char *argv[])
 {
     uint64_t now, start;
+#if 0
     u_int ops_seconds;
     int ch, reps;
+#else
+    int ch;
+#endif
     const char *config, *home;
     bool is_backup, quiet_flag, verify_only;
 
@@ -355,6 +359,7 @@ main(int argc, char *argv[])
     if (!g.reopen)
         TIMED_MAJOR_OP(wts_load());
     TIMED_MAJOR_OP(wts_verify(g.wts_conn, true));
+#if 0
     if (verify_only)
         goto skip_operations;
     TIMED_MAJOR_OP(tables_apply(wts_read_scan, g.wts_conn));
@@ -379,8 +384,10 @@ main(int argc, char *argv[])
     TIMED_MAJOR_OP(wts_stats());
 
 skip_operations:
+#endif
     locks_destroy(g.wts_conn);
 
+#if 0
     /*
      * Verify the objects. Verify closes the underlying handle and discards the statistics, read
      * them first. However, for verify_only we've already completed the verification above. Skip
@@ -388,13 +395,16 @@ skip_operations:
      */
     if (!verify_only)
         TIMED_MAJOR_OP(wts_verify(g.wts_conn, true));
+#endif
 
     track("shutting down", 0ULL);
     wts_close(&g.wts_conn);
 
+#if 0
     /* Salvage testing. */
     if (!verify_only)
         TIMED_MAJOR_OP(tables_apply(wts_salvage, NULL));
+#endif
 
     trace_teardown();
 
diff --git a/test/format/verify.c b/test/format/verify.c
index 27dd06696a..5287f2cc17 100644
--- a/test/format/verify.c
+++ b/test/format/verify.c
@@ -93,6 +93,8 @@ table_mirror_fail_msg(WT_SESSION *session, const char *checkpoint, TABLE *base,
 {
     if (checkpoint != NULL)
         trace_msg(session, "checkpoint %s\n", checkpoint);
+    /* If we have a failure, flush the log to make sure any debug messages are out of WT. */
+    (void)session->log_flush(session, "sync=off");
     trace_msg(session,
       "mirror: %" PRIu64 "/%" PRIu64 " mismatch: %s: {%.*s}/{%.*s}, %s: {%.*s}/{%.*s}\n",
       base_keyno, table_keyno, base->uri, base->type == ROW ? (int)base_key->size : 1,
