diff --git a/buildscripts/resmokeconfig/suites/core_txns.yml b/buildscripts/resmokeconfig/suites/core_txns.yml
index c396fd7027b..5ca021e7b6b 100644
--- a/buildscripts/resmokeconfig/suites/core_txns.yml
+++ b/buildscripts/resmokeconfig/suites/core_txns.yml
@@ -14,18 +14,9 @@ selector:
   - requires_capped
 
 executor:
-  archive:
-    hooks:
-      - ValidateCollections
   config:
     shell_options:
       eval: "testingReplication = true;"
-  hooks:
-  # We don't execute dbHash or oplog consistency checks since there is only a single replica set
-  # node.
-  - class: ValidateCollections
-  - class: CleanEveryN
-    n: 20
   fixture:
     class: ReplicaSetFixture
     mongod_options:
diff --git a/jstests/core/txns/commit_prepared_transaction_errors.js b/jstests/core/txns/commit_prepared_transaction_errors.js
index 64b27f3c16c..10ff477ebee 100644
--- a/jstests/core/txns/commit_prepared_transaction_errors.js
+++ b/jstests/core/txns/commit_prepared_transaction_errors.js
@@ -7,6 +7,11 @@
 "use strict";
 load("jstests/core/txns/libs/prepare_helpers.js");
 
+assert.commandWorked(db.getSiblingDB("admin").runCommand({
+    setParameter: 1,
+    logLevel: 1,
+}));
+
 const dbName = "test";
 const collName = "commit_prepared_transaction_errors";
 const testDB = db.getSiblingDB(dbName);
@@ -15,58 +20,41 @@ const testColl = testDB.getCollection(collName);
 testColl.drop({writeConcern: {w: "majority"}});
 assert.commandWorked(testDB.runCommand({create: collName, writeConcern: {w: "majority"}}));
 
-const session = db.getMongo().startSession({causalConsistency: false});
-const sessionDB = session.getDatabase(dbName);
-const sessionColl = sessionDB.getCollection(collName);
-
 const doc = {
     _id: 1
 };
 
-jsTestLog("Test committing a prepared transaction with no 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-PrepareHelpers.prepareTransaction(session);
-assert.commandFailedWithCode(sessionDB.adminCommand({commitTransaction: 1}),
-                             ErrorCodes.InvalidOptions);
-// Make sure the transaction is still running by observing write conflicts.
-const anotherSession = db.getMongo().startSession({causalConsistency: false});
-anotherSession.startTransaction();
-assert.commandFailedWithCode(anotherSession.getDatabase(dbName).getCollection(collName).insert(doc),
-                             ErrorCodes.WriteConflict);
-assert.commandFailedWithCode(anotherSession.abortTransaction_forTesting(),
-                             ErrorCodes.NoSuchTransaction);
-// Abort the original transaction.
-assert.commandWorked(session.abortTransaction_forTesting());
-
-jsTestLog("Test committing a prepared transaction with an invalid 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-PrepareHelpers.prepareTransaction(session);
-assert.commandFailedWithCode(PrepareHelpers.commitTransaction(session, 5), ErrorCodes.TypeMismatch);
-
-jsTestLog("Test committing a prepared transaction with a null 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-PrepareHelpers.prepareTransaction(session);
-assert.commandFailedWithCode(PrepareHelpers.commitTransaction(session, Timestamp(0, 0)),
-                             ErrorCodes.InvalidOptions);
-
-jsTestLog("Test committing an unprepared transaction with a 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-let res = assert.commandFailedWithCode(PrepareHelpers.commitTransaction(session, Timestamp(3, 3)),
-                                       ErrorCodes.InvalidOptions);
-assert(res.errmsg.includes("cannot provide commitTimestamp to unprepared transaction"), res);
-
-jsTestLog("Test committing an unprepared transaction with a null 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-assert.commandFailedWithCode(PrepareHelpers.commitTransaction(session, Timestamp(0, 0)),
-                             ErrorCodes.InvalidOptions);
-
-jsTestLog("Test committing an unprepared transaction with an invalid 'commitTimestamp'.");
-session.startTransaction();
-assert.commandWorked(sessionColl.insert(doc));
-assert.commandFailedWithCode(PrepareHelpers.commitTransaction(session, 5), ErrorCodes.TypeMismatch);
+const ITERS = 1000;
+for (let i = 0; i < ITERS; i++) {
+    jsTestLog("Itr " + i);
+    const session = db.getMongo().startSession();
+    const sessionDB = session.getDatabase(dbName);
+    const sessionColl = sessionDB.getCollection(collName);
+
+    jsTestLog("Block 1");
+    session.startTransaction();
+    assert.commandWorked(sessionColl.insert(doc));
+    PrepareHelpers.prepareTransaction(session);
+
+    jsTestLog("Block 2");
+    // Make sure the transaction is still running by observing write conflicts.
+    const anotherSession = db.getMongo().startSession();
+    anotherSession.startTransaction();
+    assert.commandFailedWithCode(anotherSession.getDatabase(dbName).getCollection(collName).insert(
+                                     {_id: 1, giveMe: "conflict"}),
+                                 ErrorCodes.WriteConflict);
+
+    jsTestLog("Block 3");
+    // Abort the original transaction.
+    assert.commandWorked(session.abortTransaction_forTesting());
+
+    jsTestLog("Block 4");
+    const anotherAnotherSession = db.getMongo().startSession();
+    anotherAnotherSession.startTransaction();
+    assert.commandWorked(
+        anotherAnotherSession.getDatabase(dbName).getCollection(collName).insert(doc));
+    assert.commandWorked(anotherAnotherSession.abortTransaction_forTesting());
+
+    jsTestLog("+++ END");
+}
 }());
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
index 5cdd88dfae7..91bb39c9339 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_index.cpp
@@ -1562,6 +1562,7 @@ StatusWith<bool> WiredTigerIdIndex::_insert(OperationContext* opCtx,
     WiredTigerItem valueItem(value.getBuffer(), value.getSize());
     setKey(c, keyItem.Get());
     c->set_value(c, valueItem.Get());
+    LOGV2(00000, "+++ HERE 1");
     int ret = WT_OP_CHECK(wiredTigerCursorInsert(opCtx, c));
 
     auto& metricsCollector = ResourceConsumption::MetricsCollector::get(opCtx);
@@ -1571,6 +1572,7 @@ StatusWith<bool> WiredTigerIdIndex::_insert(OperationContext* opCtx,
         return true;
     } else if (ret != WT_DUPLICATE_KEY) {
         return wtRCToStatus(ret, [this]() {
+            LOGV2(00000, "+++ HERE 2");
             return fmt::format("WiredTigerIdIndex::_insert: index: {}; uri: {}", _indexName, _uri);
         });
     }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
index 176ad6694af..9e1b9d379cb 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.cpp
@@ -248,7 +248,14 @@ void WiredTigerRecoveryUnit::prepareUnitOfWork() {
 
     const std::string conf = "prepare_timestamp=" + unsignedHex(_prepareTimestamp.asULL());
     // Prepare the transaction.
+    LOGV2(6268500,
+          "(1) WT_SESSION::prepare_transaction",
+          "config"_attr = conf,
+          "session"_attr = sessionPtrStr(),
+          "snapshotId"_attr = getSnapshotId().toNumber(),
+          "prepTS"_attr = _prepareTimestamp);
     invariantWTOK(s->prepare_transaction(s, conf.c_str()));
+    LOGV2(6268501, "(2) WT_SESSION::prepare_transaction", "session"_attr = sessionPtrStr());
 }
 
 void WiredTigerRecoveryUnit::doCommitUnitOfWork() {
@@ -488,7 +495,16 @@ void WiredTigerRecoveryUnit::_txnClose(bool commit) {
             invariant(_isTimestamped);
         }
 
+        LOGV2(6268502,
+              "(1) WT_SESSION::commit_transaction",
+              "config"_attr = conf.str(),
+              "session"_attr = sessionPtrStr(),
+              "snapshotId"_attr = getSnapshotId().toNumber());
         wtRet = s->commit_transaction(s, conf.str().c_str());
+        LOGV2(6268503,
+              "(2) WT_SESSION::commit_transaction",
+              "ret"_attr = wtRet,
+              "session"_attr = sessionPtrStr());
 
         LOGV2_DEBUG(
             22412, 3, "WT commit_transaction", "snapshotId"_attr = getSnapshotId().toNumber());
@@ -502,7 +518,16 @@ void WiredTigerRecoveryUnit::_txnClose(bool commit) {
             config << "operation_timeout_ms=1,";
         }
 
+        LOGV2(6268504,
+              "(1) WT_SESSION::rollback_transaction",
+              "config"_attr = config.str(),
+              "session"_attr = sessionPtrStr(),
+              "snapshotId"_attr = getSnapshotId().toNumber());
         wtRet = s->rollback_transaction(s, config.str().c_str());
+        LOGV2(6268505,
+              "(2) WT_SESSION::rollback_transaction",
+              "ret"_attr = wtRet,
+              "session"_attr = sessionPtrStr());
 
         LOGV2_DEBUG(
             22413, 3, "WT rollback_transaction", "snapshotId"_attr = getSnapshotId().toNumber());
@@ -665,6 +690,12 @@ void WiredTigerRecoveryUnit::_txnOpen() {
         }
     }
 
+    LOGV2(6268502,
+          "(1) WT_SESSION::begin_transaction",
+          "readAtTimestamp"_attr = _readAtTimestamp,
+          "session"_attr = sessionPtrStr(),
+          "snapshotId"_attr = getSnapshotId().toNumber());
+
     LOGV2_DEBUG(22414,
                 3,
                 "WT begin_transaction",
@@ -849,7 +880,19 @@ Status WiredTigerRecoveryUnit::setTimestamp(Timestamp timestamp) {
     }
 
     const std::string conf = "commit_timestamp=" + unsignedHex(timestamp.asULL());
+
+    LOGV2(6268506,
+          "(1) WT_SESSION::timestamp_transaction",
+          "config"_attr = conf,
+          "session"_attr = sessionPtrStr(),
+          "snapshotId"_attr = getSnapshotId().toNumber(),
+          "commitTS"_attr = timestamp);
     auto rc = session->timestamp_transaction(session, conf.c_str());
+    LOGV2(6268507,
+          "(2) WT_SESSION::timestamp_transaction",
+          "config"_attr = rc,
+          "session"_attr = sessionPtrStr());
+
     if (rc == 0) {
         _isTimestamped = true;
     }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h
index 70b13ffa3f2..8dbe9ceb59d 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_recovery_unit.h
@@ -278,6 +278,13 @@ private:
     WiredTigerSessionCache* _sessionCache;  // not owned
     WiredTigerOplogManager* _oplogManager;  // not owned
     UniqueWiredTigerSession _session;
+
+    std::string sessionPtrStr() const {
+        std::ostringstream oss;
+        oss << (void*)(_session->getSession());
+        return std::string(oss.str());
+    }
+
     bool _isTimestamped = false;
 
     // Helpers used to keep track of multi timestamp constraint violations on the transaction.
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
index b3b4c78b5d5..54ca2661d19 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_util.cpp
@@ -1169,8 +1169,6 @@ std::string WiredTigerUtil::generateWTVerboseConfiguration() {
         {logv2::LogComponent::kWiredTigerRTS, "rts"},
         {logv2::LogComponent::kWiredTigerSalvage, "salvage"},
         {logv2::LogComponent::kWiredTigerTiered, "tiered"},
-        {logv2::LogComponent::kWiredTigerTimestamp, "timestamp"},
-        {logv2::LogComponent::kWiredTigerTransaction, "transaction"},
         {logv2::LogComponent::kWiredTigerVerify, "verify"},
         {logv2::LogComponent::kWiredTigerWriteLog, "log"},
     };
@@ -1181,7 +1179,8 @@ std::string WiredTigerUtil::generateWTVerboseConfiguration() {
     cfg << "verbose=[";
 
     // Enable WiredTiger progress messages.
-    cfg << "recovery_progress:1,checkpoint_progress:1,compact_progress:1";
+    cfg << "recovery_progress:1,checkpoint_progress:1,compact_progress:1,transaction:1,timestamp:1,"
+           "write:1";
 
     // Process each LOGV2 WiredTiger component and set the desired verbosity level.
     for (const auto& [component, componentStr] : *wtVerboseComponents) {
