diff --git a/src/btree/bt_cursor.c b/src/btree/bt_cursor.c
index 0f6b569b7..565e60f69 100644
--- a/src/btree/bt_cursor.c
+++ b/src/btree/bt_cursor.c
@@ -90,7 +90,7 @@ __cursor_page_pinned(WT_CURSOR_BTREE *cbt, bool search_operation)
      * functions, but in the case of a search, we will see different results based on the cursor's
      * initial location. See WT-5134 for the details.
      */
-    if (search_operation && session->txn.isolation == WT_ISO_READ_COMMITTED)
+    if (search_operation && session->txn->isolation == WT_ISO_READ_COMMITTED)
         return (false);
 
     /*
@@ -1433,11 +1433,11 @@ __wt_btcur_modify(WT_CURSOR_BTREE *cbt, WT_MODIFY *entries, int nentries)
      * time and the failure is unlikely to be detected. Require explicit transactions for modify
      * operations.
      */
-    if (session->txn.isolation != WT_ISO_SNAPSHOT)
+    if (session->txn->isolation != WT_ISO_SNAPSHOT)
         WT_ERR_MSG(session, ENOTSUP,
           "not supported in read-committed or read-uncommitted "
           "transactions");
-    if (F_ISSET(&session->txn, WT_TXN_AUTOCOMMIT))
+    if (F_ISSET(session->txn, WT_TXN_AUTOCOMMIT))
         WT_ERR_MSG(session, ENOTSUP, "not supported in implicit transactions");
 
     if (!F_ISSET(cursor, WT_CURSTD_KEY_INT) || !F_ISSET(cursor, WT_CURSTD_VALUE_INT))
diff --git a/src/btree/bt_debug.c b/src/btree/bt_debug.c
index d4babb1df..9f916b375 100644
--- a/src/btree/bt_debug.c
+++ b/src/btree/bt_debug.c
@@ -705,18 +705,9 @@ int
 __wt_debug_cursor_las(void *cursor_arg, const char *ofile)
   WT_GCC_FUNC_ATTRIBUTE((visibility("default")))
 {
-    WT_CONNECTION_IMPL *conn;
-    WT_CURSOR *cursor;
-    WT_CURSOR_BTREE *cbt;
-    WT_SESSION_IMPL *las_session;
-
-    cursor = cursor_arg;
-    conn = S2C((WT_SESSION_IMPL *)cursor->session);
-    las_session = conn->cache->las_session[0];
-    if (las_session == NULL)
-        return (0);
-    cbt = (WT_CURSOR_BTREE *)las_session->las_cursor;
-    return (__wt_debug_tree_all(las_session, cbt->btree, NULL, ofile));
+    WT_UNUSED(cursor_arg);
+    WT_UNUSED(ofile);
+    return (0);
 }
 
 /*
diff --git a/src/btree/bt_read.c b/src/btree/bt_read.c
index ddf47a43c..7542126c5 100644
--- a/src/btree/bt_read.c
+++ b/src/btree/bt_read.c
@@ -150,7 +150,7 @@ __las_page_instantiate(WT_SESSION_IMPL *session, WT_REF *ref)
     WT_ERR(__wt_scr_alloc(session, 0, &current_key));
 
     /* Open a lookaside table cursor. */
-    __wt_las_cursor(session, &cursor, &session_flags);
+    WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
 
     /*
      * The lookaside records are in key and update order, that is, there will be a set of in-order
@@ -636,7 +636,7 @@ read:
              */
             if (!LF_ISSET(WT_READ_IGNORE_CACHE_SIZE))
                 WT_RET(__wt_cache_eviction_check(
-                  session, true, !F_ISSET(&session->txn, WT_TXN_HAS_ID), NULL));
+                  session, true, !F_ISSET(session->txn, WT_TXN_HAS_ID), NULL));
             WT_RET(__page_read(session, ref, flags));
 
             /*
diff --git a/src/btree/bt_sync.c b/src/btree/bt_sync.c
index f72977299..c5dcd7c82 100644
--- a/src/btree/bt_sync.c
+++ b/src/btree/bt_sync.c
@@ -21,7 +21,7 @@ __sync_checkpoint_can_skip(WT_SESSION_IMPL *session, WT_PAGE *page)
     u_int i;
 
     mod = page->modify;
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * We can skip some dirty pages during a checkpoint. The requirements:
@@ -122,7 +122,7 @@ __wt_sync_file(WT_SESSION_IMPL *session, WT_CACHE_OP syncop)
     conn = S2C(session);
     btree = S2BT(session);
     prev = walk = NULL;
-    txn = &session->txn;
+    txn = session->txn;
     tried_eviction = false;
     time_start = time_stop = 0;
 
diff --git a/src/cache/cache_las.c b/src/cache/cache_las.c
index 2cacc57e6..8e0cc191c 100644
--- a/src/cache/cache_las.c
+++ b/src/cache/cache_las.c
@@ -23,8 +23,8 @@
 static void
 __las_set_isolation(WT_SESSION_IMPL *session, WT_TXN_ISOLATION *saved_isolationp)
 {
-    *saved_isolationp = session->txn.isolation;
-    session->txn.isolation = WT_ISO_READ_UNCOMMITTED;
+    *saved_isolationp = session->txn->isolation;
+    session->txn->isolation = WT_ISO_READ_UNCOMMITTED;
 }
 
 /*
@@ -34,7 +34,7 @@ __las_set_isolation(WT_SESSION_IMPL *session, WT_TXN_ISOLATION *saved_isolationp
 static void
 __las_restore_isolation(WT_SESSION_IMPL *session, WT_TXN_ISOLATION saved_isolation)
 {
-    session->txn.isolation = saved_isolation;
+    session->txn->isolation = saved_isolation;
 }
 
 /*
@@ -59,31 +59,8 @@ __las_entry_count(WT_CACHE *cache)
 int
 __wt_las_config(WT_SESSION_IMPL *session, const char **cfg)
 {
-    WT_CONFIG_ITEM cval;
-    WT_CURSOR_BTREE *las_cursor;
-    WT_SESSION_IMPL *las_session;
-
-    WT_RET(__wt_config_gets(session, cfg, "cache_overflow.file_max", &cval));
-
-    if (cval.val != 0 && cval.val < WT_LAS_FILE_MIN)
-        WT_RET_MSG(session, EINVAL, "max cache overflow size %" PRId64 " below minimum %d",
-          cval.val, WT_LAS_FILE_MIN);
-
-    /* This is expected for in-memory configurations. */
-    las_session = S2C(session)->cache->las_session[0];
-    WT_ASSERT(session, las_session != NULL || F_ISSET(S2C(session), WT_CONN_IN_MEMORY));
-
-    if (las_session == NULL)
-        return (0);
-
-    /*
-     * We need to set file_max on the btree associated with one of the lookaside sessions.
-     */
-    las_cursor = (WT_CURSOR_BTREE *)las_session->las_cursor;
-    las_cursor->btree->file_max = (uint64_t)cval.val;
-
-    WT_STAT_CONN_SET(session, cache_lookaside_ondisk_max, las_cursor->btree->file_max);
-
+    WT_UNUSED(session);
+    WT_UNUSED(cfg);
     return (0);
 }
 
@@ -107,8 +84,12 @@ __wt_las_stats_update(WT_SESSION_IMPL *session)
     WT_CACHE *cache;
     WT_CONNECTION_IMPL *conn;
     WT_CONNECTION_STATS **cstats;
+    WT_CURSOR *cursor;
+    WT_DECL_RET;
     WT_DSRC_STATS **dstats;
     int64_t v;
+    uint32_t session_flags;
+    session_flags = 0;
 
     conn = S2C(session);
     cache = conn->cache;
@@ -129,7 +110,12 @@ __wt_las_stats_update(WT_SESSION_IMPL *session)
      * We have a cursor, and we need the underlying data handle; we can get to it by way of the
      * underlying btree handle, but it's a little ugly.
      */
-    dstats = ((WT_CURSOR_BTREE *)cache->las_session[0]->las_cursor)->btree->dhandle->stats;
+    ret = __wt_las_cursor(session, &cursor, &session_flags);
+    if (ret != 0)
+        return;
+
+    dstats = ((WT_CURSOR_BTREE *)cursor)->btree->dhandle->stats;
+    WT_IGNORE_RET(__wt_las_cursor_close(session, &cursor, session_flags));
 
     v = WT_STAT_READ(dstats, cursor_update);
     WT_STAT_SET(session, cstats, cache_lookaside_insert, v);
@@ -154,14 +140,11 @@ __wt_las_stats_update(WT_SESSION_IMPL *session)
 int
 __wt_las_create(WT_SESSION_IMPL *session, const char **cfg)
 {
-    WT_CACHE *cache;
     WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
-    int i;
     const char *drop_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_drop), "force=true", NULL};
 
     conn = S2C(session);
-    cache = conn->cache;
 
     /* Read-only and in-memory configurations don't need the LAS table. */
     if (F_ISSET(conn, WT_CONN_IN_MEMORY | WT_CONN_READONLY))
@@ -183,11 +166,13 @@ __wt_las_create(WT_SESSION_IMPL *session, const char **cfg)
      * Open a shared internal session and cursor used for the lookaside table. This session should
      * never perform reconciliation.
      */
+    /*
     for (i = 0; i < WT_LAS_NUM_SESSIONS; i++) {
         WT_RET(__wt_open_internal_session(
           conn, "lookaside table", true, WT_LAS_SESSION_FLAGS, &cache->las_session[i]));
         WT_RET(__wt_las_cursor_open(cache->las_session[i]));
     }
+    */
 
     WT_RET(__wt_las_config(session, cfg));
 
@@ -208,8 +193,8 @@ __wt_las_destroy(WT_SESSION_IMPL *session)
     WT_CACHE *cache;
     WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
-    WT_SESSION *wt_session;
-    int i;
+    // WT_SESSION *wt_session;
+    // int i;
 
     conn = S2C(session);
     cache = conn->cache;
@@ -217,16 +202,16 @@ __wt_las_destroy(WT_SESSION_IMPL *session)
     F_CLR(conn, WT_CONN_LOOKASIDE_OPEN);
     if (cache == NULL)
         return (0);
+    /*
+        for (i = 0; i < WT_LAS_NUM_SESSIONS; i++) {
+            if (cache->las_session[i] == NULL)
+                continue;
 
-    for (i = 0; i < WT_LAS_NUM_SESSIONS; i++) {
-        if (cache->las_session[i] == NULL)
-            continue;
-
-        wt_session = &cache->las_session[i]->iface;
-        WT_TRET(wt_session->close(wt_session, NULL));
-        cache->las_session[i] = NULL;
-    }
-
+            wt_session = &cache->las_session[i]->iface;
+            WT_TRET(wt_session->close(wt_session, NULL));
+            cache->las_session[i] = NULL;
+        }
+    */
     __wt_buf_free(session, &cache->las_sweep_key);
     __wt_free(session, cache->las_dropped);
     __wt_free(session, cache->las_sweep_dropmap);
@@ -275,6 +260,7 @@ __wt_las_cursor_open(WT_SESSION_IMPL *session)
         F_SET(btree, WT_BTREE_NO_LOGGING);
 
     session->las_cursor = cursor;
+    // Can continue to use this flag to say that cursor is currently active/open
     F_SET(session, WT_SESSION_LOOKASIDE_CURSOR);
 
     return (0);
@@ -284,12 +270,9 @@ __wt_las_cursor_open(WT_SESSION_IMPL *session)
  * __wt_las_cursor --
  *     Return a lookaside cursor.
  */
-void
+int
 __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags)
 {
-    WT_CACHE *cache;
-    int i;
-
     *cursorp = NULL;
 
     /*
@@ -299,43 +282,21 @@ __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session
      * Don't cache lookaside table pages, we're here because of eviction problems and there's no
      * reason to believe lookaside pages will be useful more than once.
      */
+    // These flags need checking
     *session_flags = F_MASK(session, WT_LAS_SESSION_FLAGS);
 
-    cache = S2C(session)->cache;
-
     /*
-     * Some threads have their own lookaside table cursors, else lock the shared lookaside cursor.
+     * If the las cursor for this session is already open
      */
-    if (F_ISSET(session, WT_SESSION_LOOKASIDE_CURSOR))
-        *cursorp = session->las_cursor;
-    else {
-        for (;;) {
-            __wt_spin_lock(session, &cache->las_lock);
-            for (i = 0; i < WT_LAS_NUM_SESSIONS; i++) {
-                if (!cache->las_session_inuse[i]) {
-                    *cursorp = cache->las_session[i]->las_cursor;
-                    cache->las_session_inuse[i] = true;
-                    break;
-                }
-            }
-            __wt_spin_unlock(session, &cache->las_lock);
-            if (*cursorp != NULL)
-                break;
-            /*
-             * If all the lookaside sessions are busy, stall.
-             *
-             * XXX better as a condition variable.
-             */
-            __wt_sleep(0, WT_THOUSAND);
-            if (F_ISSET(session, WT_SESSION_INTERNAL))
-                WT_STAT_CONN_INCRV(session, cache_lookaside_cursor_wait_internal, WT_THOUSAND);
-            else
-                WT_STAT_CONN_INCRV(session, cache_lookaside_cursor_wait_application, WT_THOUSAND);
-        }
-    }
+    if (!F_ISSET(session, WT_SESSION_LOOKASIDE_CURSOR))
+        WT_RET(__wt_las_cursor_open(session));
+
+    *cursorp = session->las_cursor;
 
     /* Configure session to access the lookaside table. */
+    // These flags need reviewing
     F_SET(session, WT_LAS_SESSION_FLAGS);
+    return (0);
 }
 
 /*
@@ -345,12 +306,8 @@ __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session
 int
 __wt_las_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t session_flags)
 {
-    WT_CACHE *cache;
     WT_CURSOR *cursor;
     WT_DECL_RET;
-    int i;
-
-    cache = S2C(session)->cache;
 
     if ((cursor = *cursorp) == NULL)
         return (0);
@@ -366,19 +323,10 @@ __wt_las_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t se
     F_CLR(session, WT_LAS_SESSION_FLAGS);
     F_SET(session, session_flags);
 
-    /*
-     * Some threads have their own lookaside table cursors, else unlock the shared lookaside cursor.
-     */
-    if (!F_ISSET(session, WT_SESSION_LOOKASIDE_CURSOR)) {
-        __wt_spin_lock(session, &cache->las_lock);
-        for (i = 0; i < WT_LAS_NUM_SESSIONS; i++)
-            if (cursor->session == &cache->las_session[i]->iface) {
-                cache->las_session_inuse[i] = false;
-                break;
-            }
-        __wt_spin_unlock(session, &cache->las_lock);
-        WT_ASSERT(session, i != WT_LAS_NUM_SESSIONS);
-    }
+    WT_RET(cursor->close(cursor));
+    F_CLR(session, WT_SESSION_LOOKASIDE_CURSOR);
+
+    ret = 0;
 
     return (ret);
 }
@@ -392,7 +340,7 @@ __wt_las_page_skip_locked(WT_SESSION_IMPL *session, WT_REF *ref)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * Skip lookaside pages if reading without a timestamp and all the updates in lookaside are in
@@ -630,17 +578,6 @@ __wt_las_insert_block(
     if (!btree->lookaside_entries)
         btree->lookaside_entries = true;
 
-#ifdef HAVE_DIAGNOSTIC
-    {
-        uint64_t remove_cnt;
-        /*
-         * There should never be any entries with the page ID we are about to use.
-         */
-        WT_RET_BUSY_OK(__las_remove_block(cursor, las_pageid, false, &remove_cnt));
-        WT_ASSERT(session, remove_cnt == 0);
-    }
-#endif
-
     /* Wrap all the updates in a transaction. */
     WT_ERR(__wt_txn_begin(session, NULL));
     __las_set_isolation(session, &saved_isolation);
@@ -864,7 +801,7 @@ __wt_las_remove_block(WT_SESSION_IMPL *session, uint64_t pageid)
      * lookaside table cursor and enclosing transaction, then calling an underlying function to do
      * the work.
      */
-    __wt_las_cursor(session, &cursor, &session_flags);
+    WT_RET(__wt_las_cursor(session, &cursor, &session_flags));
 
     if ((ret = __las_remove_block(cursor, pageid, true, &remove_cnt)) == 0)
         (void)__wt_atomic_add64(&conn->cache->las_remove_count, remove_cnt);
@@ -1045,7 +982,7 @@ __wt_las_sweep(WT_SESSION_IMPL *session)
      * Allocate a cursor and wrap all the updates in a transaction. We should have our own lookaside
      * cursor.
      */
-    __wt_las_cursor(session, &cursor, &session_flags);
+    WT_ERR(__wt_las_cursor(session, &cursor, &session_flags));
     WT_ASSERT(session, cursor->session == &session->iface);
     WT_ERR(__wt_txn_begin(session, NULL));
     local_txn = true;
diff --git a/src/conn/conn_api.c b/src/conn/conn_api.c
index 7013ca582..0cdd07327 100644
--- a/src/conn/conn_api.c
+++ b/src/conn/conn_api.c
@@ -1033,7 +1033,7 @@ err:
      * never referenced that file.
      */
     for (s = conn->sessions, i = 0; i < conn->session_cnt; ++s, ++i)
-        if (s->active && !F_ISSET(s, WT_SESSION_INTERNAL) && F_ISSET(&s->txn, WT_TXN_RUNNING)) {
+        if (s->active && !F_ISSET(s, WT_SESSION_INTERNAL) && F_ISSET(s->txn, WT_TXN_RUNNING)) {
             wt_session = &s->iface;
             WT_TRET(wt_session->rollback_transaction(wt_session, NULL));
         }
@@ -1920,7 +1920,7 @@ __wt_verbose_dump_sessions(WT_SESSION_IMPL *session, bool show_cursors)
                   "read-committed" :
                   (s->isolation == WT_ISO_READ_UNCOMMITTED ? "read-uncommitted" : "snapshot")));
             WT_ERR(__wt_msg(session, "  Transaction:"));
-            WT_ERR(__wt_verbose_dump_txn_one(session, &s->txn, 0, NULL));
+            WT_ERR(__wt_verbose_dump_txn_one(session, s->txn, 0, NULL));
         } else {
             WT_ERR(__wt_msg(session, "  Number of positioned cursors: %u", s->ncursors));
             TAILQ_FOREACH (cursor, &s->cursors, q) {
diff --git a/src/conn/conn_sweep.c b/src/conn/conn_sweep.c
index b762a4d8f..6d660308b 100644
--- a/src/conn/conn_sweep.c
+++ b/src/conn/conn_sweep.c
@@ -307,8 +307,8 @@ __sweep_server(void *arg)
          * progress in eviction, sweeping can wind up constantly bringing in and evicting pages from
          * the lookaside table, which will stop the cache from moving into the stuck state.
          */
-        if ((FLD_ISSET(conn->timing_stress_flags, WT_TIMING_STRESS_AGGRESSIVE_SWEEP) ||
-              now - last >= WT_LAS_SWEEP_SEC) &&
+        if (false && (FLD_ISSET(conn->timing_stress_flags, WT_TIMING_STRESS_AGGRESSIVE_SWEEP) ||
+                       now - last >= WT_LAS_SWEEP_SEC) &&
           !__wt_las_empty(session) && !__wt_cache_stuck(session)) {
             oldest_id = __wt_txn_oldest_id(session);
             if (WT_TXNID_LT(last_las_sweep_id, oldest_id)) {
diff --git a/src/cursor/cur_join.c b/src/cursor/cur_join.c
index 5b2dc711a..09bddaf91 100644
--- a/src/cursor/cur_join.c
+++ b/src/cursor/cur_join.c
@@ -926,7 +926,7 @@ __curjoin_init_next(WT_SESSION_IMPL *session, WT_CURSOR_JOIN *cjoin, bool iterab
          * doing any needed check during the iteration.
          */
         if (!iterable && F_ISSET(je, WT_CURJOIN_ENTRY_BLOOM)) {
-            if (session->txn.isolation == WT_ISO_READ_UNCOMMITTED)
+            if (session->txn->isolation == WT_ISO_READ_UNCOMMITTED)
                 WT_ERR_MSG(session, EINVAL,
                   "join cursors with Bloom filters cannot be "
                   "used with read-uncommitted isolation");
diff --git a/src/cursor/cur_std.c b/src/cursor/cur_std.c
index 6140b453f..7e3d8b1f1 100644
--- a/src/cursor/cur_std.c
+++ b/src/cursor/cur_std.c
@@ -905,11 +905,11 @@ __cursor_modify(WT_CURSOR *cursor, WT_MODIFY *entries, int nentries)
      * read-uncommitted transaction, or outside of an explicit transaction. Disallow here as well,
      * for consistency.
      */
-    if (session->txn.isolation != WT_ISO_SNAPSHOT)
+    if (session->txn->isolation != WT_ISO_SNAPSHOT)
         WT_ERR_MSG(session, ENOTSUP,
           "not supported in read-committed or read-uncommitted "
           "transactions");
-    if (F_ISSET(&session->txn, WT_TXN_AUTOCOMMIT))
+    if (F_ISSET(session->txn, WT_TXN_AUTOCOMMIT))
         WT_ERR_MSG(session, ENOTSUP, "not supported in implicit transactions");
 
     WT_ERR(__cursor_checkkey(cursor));
diff --git a/src/include/api.h b/src/include/api.h
index 533f276b1..1e2410353 100644
--- a/src/include/api.h
+++ b/src/include/api.h
@@ -68,8 +68,8 @@
         WT_TRACK_OP_END(s);                                                    \
         WT_SINGLE_THREAD_CHECK_STOP(s);                                        \
         if ((ret) != 0 && (ret) != WT_NOTFOUND && (ret) != WT_DUPLICATE_KEY && \
-          (ret) != WT_PREPARE_CONFLICT && F_ISSET(&(s)->txn, WT_TXN_RUNNING))  \
-            F_SET(&(s)->txn, WT_TXN_ERROR);                                    \
+          (ret) != WT_PREPARE_CONFLICT && F_ISSET((s)->txn, WT_TXN_RUNNING))  \
+            F_SET((s)->txn, WT_TXN_ERROR);                                    \
         __wt_op_timer_stop(s);                                                 \
         /*                                                                     \
          * No code after this line, otherwise error handling                   \
@@ -87,12 +87,12 @@
         bool __autotxn = false, __update = false;                            \
         API_CALL(s, h, n, bt, config, cfg);                                  \
         __wt_txn_timestamp_flags(s);                                         \
-        __autotxn = !F_ISSET(&(s)->txn, WT_TXN_AUTOCOMMIT | WT_TXN_RUNNING); \
+        __autotxn = !F_ISSET((s)->txn, WT_TXN_AUTOCOMMIT | WT_TXN_RUNNING); \
         if (__autotxn)                                                       \
-            F_SET(&(s)->txn, WT_TXN_AUTOCOMMIT);                             \
-        __update = !F_ISSET(&(s)->txn, WT_TXN_UPDATE);                       \
+            F_SET((s)->txn, WT_TXN_AUTOCOMMIT);                             \
+        __update = !F_ISSET((s)->txn, WT_TXN_UPDATE);                       \
         if (__update)                                                        \
-            F_SET(&(s)->txn, WT_TXN_UPDATE);
+            F_SET((s)->txn, WT_TXN_UPDATE);
 
 /* An API call wrapped in a transaction if necessary. */
 #define TXN_API_CALL_NOCONF(s, h, n, dh)                                     \
@@ -100,22 +100,22 @@
         bool __autotxn = false, __update = false;                            \
         API_CALL_NOCONF(s, h, n, dh);                                        \
         __wt_txn_timestamp_flags(s);                                         \
-        __autotxn = !F_ISSET(&(s)->txn, WT_TXN_AUTOCOMMIT | WT_TXN_RUNNING); \
+        __autotxn = !F_ISSET((s)->txn, WT_TXN_AUTOCOMMIT | WT_TXN_RUNNING); \
         if (__autotxn)                                                       \
-            F_SET(&(s)->txn, WT_TXN_AUTOCOMMIT);                             \
-        __update = !F_ISSET(&(s)->txn, WT_TXN_UPDATE);                       \
+            F_SET((s)->txn, WT_TXN_AUTOCOMMIT);                             \
+        __update = !F_ISSET((s)->txn, WT_TXN_UPDATE);                       \
         if (__update)                                                        \
-            F_SET(&(s)->txn, WT_TXN_UPDATE);
+            F_SET((s)->txn, WT_TXN_UPDATE);
 
 /* End a transactional API call, optional retry on deadlock. */
 #define TXN_API_END_RETRY(s, ret, retry)                           \
     API_END(s, ret);                                               \
     if (__update)                                                  \
-        F_CLR(&(s)->txn, WT_TXN_UPDATE);                           \
+        F_CLR((s)->txn, WT_TXN_UPDATE);                           \
     if (__autotxn) {                                               \
-        if (F_ISSET(&(s)->txn, WT_TXN_AUTOCOMMIT))                 \
-            F_CLR(&(s)->txn, WT_TXN_AUTOCOMMIT);                   \
-        else if ((ret) == 0 && !F_ISSET(&(s)->txn, WT_TXN_ERROR))  \
+        if (F_ISSET((s)->txn, WT_TXN_AUTOCOMMIT))                 \
+            F_CLR((s)->txn, WT_TXN_AUTOCOMMIT);                   \
+        else if ((ret) == 0 && !F_ISSET((s)->txn, WT_TXN_ERROR))  \
             (ret) = __wt_txn_commit((s), NULL);                    \
         else {                                                     \
             if (retry)                                             \
diff --git a/src/include/btree.i b/src/include/btree.i
index 5099bc4dc..bc7a3e2a7 100644
--- a/src/include/btree.i
+++ b/src/include/btree.i
@@ -511,8 +511,8 @@ __wt_page_only_modify_set(WT_SESSION_IMPL *session, WT_PAGE *page)
     }
 
     /* Check if this is the largest transaction ID to update the page. */
-    if (WT_TXNID_LT(page->modify->update_txn, session->txn.id))
-        page->modify->update_txn = session->txn.id;
+    if (WT_TXNID_LT(page->modify->update_txn, session->txn->id))
+        page->modify->update_txn = session->txn->id;
 }
 
 /*
diff --git a/src/include/cache.h b/src/include/cache.h
index 881733a88..dad5becbf 100644
--- a/src/include/cache.h
+++ b/src/include/cache.h
@@ -192,7 +192,6 @@ struct __wt_cache {
      * own lookaside cursors).
      */
     WT_SPINLOCK las_lock;
-    WT_SESSION_IMPL *las_session[WT_LAS_NUM_SESSIONS];
     bool las_session_inuse[WT_LAS_NUM_SESSIONS];
 
     uint32_t las_fileid;       /* Lookaside table file ID */
diff --git a/src/include/dhandle.h b/src/include/dhandle.h
index 016741400..0951261d3 100644
--- a/src/include/dhandle.h
+++ b/src/include/dhandle.h
@@ -6,6 +6,16 @@
  * See the file LICENSE for redistribution information.
  */
 
+/*
+ * Helper function to switch session to las txn and then restore back
+ */
+#define WT_WITH_LAS_TXN(s, e)                           \
+    do {                                                \
+        (s)->txn = &(s)->las_txn;                       \
+        e;                                              \
+        (s)->txn = &(s)->session_txn;                   \
+    } while (0)
+
 /*
  * Helpers for calling a function with a data handle in session->dhandle then restoring afterwards.
  */
diff --git a/src/include/extern.h b/src/include/extern.h
index 5e530b8aa..45a7f746a 100644
--- a/src/include/extern.h
+++ b/src/include/extern.h
@@ -758,6 +758,8 @@ extern int __wt_las_config(WT_SESSION_IMPL *session, const char **cfg)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_create(WT_SESSION_IMPL *session, const char **cfg)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_cursor_close(WT_SESSION_IMPL *session, WT_CURSOR **cursorp,
   uint32_t session_flags) WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_las_cursor_open(WT_SESSION_IMPL *session)
@@ -1308,6 +1310,8 @@ extern int __wt_session_release_resources(WT_SESSION_IMPL *session)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_session_reset_cursors(WT_SESSION_IMPL *session, bool free_buffers)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
+extern int __wt_session_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret)
+  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_set_return_func(WT_SESSION_IMPL *session, const char *func, int line, int err)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_split_insert(WT_SESSION_IMPL *session, WT_REF *ref)
@@ -1425,8 +1429,6 @@ extern int __wt_txn_global_set_timestamp(WT_SESSION_IMPL *session, const char *c
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_txn_global_shutdown(WT_SESSION_IMPL *session, const char *config, const char **cfg)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
-extern int __wt_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret)
-  WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_txn_is_blocking(WT_SESSION_IMPL *session)
   WT_GCC_FUNC_DECL_ATTRIBUTE((warn_unused_result));
 extern int __wt_txn_log_commit(WT_SESSION_IMPL *session, const char *cfg[])
@@ -1642,7 +1644,6 @@ extern void __wt_gen_next_drain(WT_SESSION_IMPL *session, int which);
 extern void __wt_hazard_close(WT_SESSION_IMPL *session);
 extern void __wt_huffman_close(WT_SESSION_IMPL *session, void *huffman_arg);
 extern void __wt_json_close(WT_SESSION_IMPL *session, WT_CURSOR *cursor);
-extern void __wt_las_cursor(WT_SESSION_IMPL *session, WT_CURSOR **cursorp, uint32_t *session_flags);
 extern void __wt_las_remove_dropped(WT_SESSION_IMPL *session);
 extern void __wt_las_stats_update(WT_SESSION_IMPL *session);
 extern void __wt_log_background(WT_SESSION_IMPL *session, WT_LSN *lsn);
diff --git a/src/include/misc.i b/src/include/misc.i
index d739e78cf..c41a6664f 100644
--- a/src/include/misc.i
+++ b/src/include/misc.i
@@ -148,7 +148,7 @@ __wt_snprintf_len_incr(char *buf, size_t size, size_t *retsizep, const char *fmt
 static inline int
 __wt_txn_context_prepare_check(WT_SESSION_IMPL *session)
 {
-    if (F_ISSET(&session->txn, WT_TXN_PREPARE))
+    if (F_ISSET(session->txn, WT_TXN_PREPARE))
         WT_RET_MSG(session, EINVAL, "%s: not permitted in a prepared transaction", session->name);
     return (0);
 }
@@ -160,9 +160,9 @@ __wt_txn_context_prepare_check(WT_SESSION_IMPL *session)
 static inline int
 __wt_txn_context_check(WT_SESSION_IMPL *session, bool requires_txn)
 {
-    if (requires_txn && !F_ISSET(&session->txn, WT_TXN_RUNNING))
+    if (requires_txn && !F_ISSET(session->txn, WT_TXN_RUNNING))
         WT_RET_MSG(session, EINVAL, "%s: only permitted in a running transaction", session->name);
-    if (!requires_txn && F_ISSET(&session->txn, WT_TXN_RUNNING))
+    if (!requires_txn && F_ISSET(session->txn, WT_TXN_RUNNING))
         WT_RET_MSG(session, EINVAL, "%s: not permitted in a running transaction", session->name);
     return (0);
 }
diff --git a/src/include/session.h b/src/include/session.h
index f4b82b8f5..704e26593 100644
--- a/src/include/session.h
+++ b/src/include/session.h
@@ -131,7 +131,9 @@ struct __wt_session_impl {
     WT_ITEM err; /* Error buffer */
 
     WT_TXN_ISOLATION isolation;
-    WT_TXN txn; /* Transaction state */
+    WT_TXN *txn;        /* Transaction state */
+    WT_TXN session_txn; /* Session txn */
+    WT_TXN las_txn;     /* LAS txn */
 #define WT_SESSION_BG_SYNC_MSEC 1200000
     WT_LSN bg_sync_lsn; /* Background sync operation LSN. */
     u_int ncursors;     /* Count of active file cursors. */
diff --git a/src/include/time.i b/src/include/time.i
index 208243ef6..f6f653542 100644
--- a/src/include/time.i
+++ b/src/include/time.i
@@ -163,7 +163,7 @@ __wt_op_timer_start(WT_SESSION_IMPL *session)
     uint64_t timeout_us;
 
     /* Timer can be configured per-transaction, and defaults to per-connection. */
-    if ((timeout_us = session->txn.operation_timeout_us) == 0)
+    if ((timeout_us = session->txn->operation_timeout_us) == 0)
         timeout_us = S2C(session)->operation_timeout_us;
     if (timeout_us == 0)
         session->operation_start_us = session->operation_timeout_us = 0;
diff --git a/src/include/txn.h b/src/include/txn.h
index 59d201e51..b867de016 100644
--- a/src/include/txn.h
+++ b/src/include/txn.h
@@ -74,16 +74,16 @@ typedef enum {
 #define WT_WITH_TXN_ISOLATION(s, iso, op)                                 \
     do {                                                                  \
         WT_TXN_ISOLATION saved_iso = (s)->isolation;                      \
-        WT_TXN_ISOLATION saved_txn_iso = (s)->txn.isolation;              \
+        WT_TXN_ISOLATION saved_txn_iso = (s)->txn->isolation;             \
         WT_TXN_STATE *txn_state = WT_SESSION_TXN_STATE(s);                \
         WT_TXN_STATE saved_state = *txn_state;                            \
-        (s)->txn.forced_iso++;                                            \
-        (s)->isolation = (s)->txn.isolation = (iso);                      \
+        (s)->txn->forced_iso++;                                           \
+        (s)->isolation = (s)->txn->isolation = (iso);                     \
         op;                                                               \
         (s)->isolation = saved_iso;                                       \
-        (s)->txn.isolation = saved_txn_iso;                               \
-        WT_ASSERT((s), (s)->txn.forced_iso > 0);                          \
-        (s)->txn.forced_iso--;                                            \
+        (s)->txn->isolation = saved_txn_iso;                              \
+        WT_ASSERT((s), (s)->txn->forced_iso > 0);                         \
+        (s)->txn->forced_iso--;                                           \
         WT_ASSERT((s), txn_state->id == saved_state.id &&                 \
             (txn_state->metadata_pinned == saved_state.metadata_pinned || \
                          saved_state.metadata_pinned == WT_TXN_NONE) &&   \
diff --git a/src/include/txn.i b/src/include/txn.i
index 757627dff..d65c10e79 100644
--- a/src/include/txn.i
+++ b/src/include/txn.i
@@ -49,17 +49,17 @@ __wt_txn_timestamp_flags(WT_SESSION_IMPL *session)
     if (btree == NULL)
         return;
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_COMMIT_TS_ALWAYS))
-        F_SET(&session->txn, WT_TXN_TS_COMMIT_ALWAYS);
+        F_SET(session->txn, WT_TXN_TS_COMMIT_ALWAYS);
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_COMMIT_TS_KEYS))
-        F_SET(&session->txn, WT_TXN_TS_COMMIT_KEYS);
+        F_SET(session->txn, WT_TXN_TS_COMMIT_KEYS);
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_COMMIT_TS_NEVER))
-        F_SET(&session->txn, WT_TXN_TS_COMMIT_NEVER);
+        F_SET(session->txn, WT_TXN_TS_COMMIT_NEVER);
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_DURABLE_TS_ALWAYS))
-        F_SET(&session->txn, WT_TXN_TS_DURABLE_ALWAYS);
+        F_SET(session->txn, WT_TXN_TS_DURABLE_ALWAYS);
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_DURABLE_TS_KEYS))
-        F_SET(&session->txn, WT_TXN_TS_DURABLE_KEYS);
+        F_SET(session->txn, WT_TXN_TS_DURABLE_KEYS);
     if (FLD_ISSET(btree->assert_flags, WT_ASSERT_DURABLE_TS_NEVER))
-        F_SET(&session->txn, WT_TXN_TS_DURABLE_NEVER);
+        F_SET(session->txn, WT_TXN_TS_DURABLE_NEVER);
 }
 
 /*
@@ -72,7 +72,7 @@ __wt_txn_op_set_recno(WT_SESSION_IMPL *session, uint64_t recno)
     WT_TXN *txn;
     WT_TXN_OP *op;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_ASSERT(session, txn->mod_count > 0 && recno != WT_RECNO_OOB);
     op = txn->mod + txn->mod_count - 1;
@@ -103,7 +103,7 @@ __wt_txn_op_set_key(WT_SESSION_IMPL *session, const WT_ITEM *key)
     WT_TXN *txn;
     WT_TXN_OP *op;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_ASSERT(session, txn->mod_count > 0 && key->data != NULL);
 
@@ -134,7 +134,7 @@ __txn_resolve_prepared_update(WT_SESSION_IMPL *session, WT_UPDATE *upd)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
     /*
      * In case of a prepared transaction, the order of modification of the prepare timestamp to
      * commit timestamp in the update chain will not affect the data visibility, a reader will
@@ -161,7 +161,7 @@ __txn_next_op(WT_SESSION_IMPL *session, WT_TXN_OP **opp)
 
     *opp = NULL;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * We're about to perform an update. Make sure we have allocated a transaction ID.
@@ -190,7 +190,7 @@ __wt_txn_unmodify(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     WT_TXN_OP *op;
 
-    txn = &session->txn;
+    txn = session->txn;
     if (F_ISSET(txn, WT_TXN_HAS_ID)) {
         WT_ASSERT(session, txn->mod_count > 0);
         --txn->mod_count;
@@ -213,7 +213,7 @@ __wt_txn_op_apply_prepare_state(WT_SESSION_IMPL *session, WT_REF *ref, bool comm
     uint32_t previous_state;
     uint8_t prepare_state;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * Lock the ref to ensure we don't race with eviction freeing the page deleted update list or
@@ -264,7 +264,7 @@ __wt_txn_op_delete_commit_apply_timestamps(WT_SESSION_IMPL *session, WT_REF *ref
     WT_UPDATE **updp;
     uint32_t previous_state;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * Lock the ref to ensure we don't race with eviction freeing the page deleted update list or
@@ -300,7 +300,7 @@ __wt_txn_op_set_timestamp(WT_SESSION_IMPL *session, WT_TXN_OP *op)
     WT_UPDATE *upd;
     wt_timestamp_t *timestamp;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * Updates in the metadata never get timestamps (either now or at commit): metadata cannot be
@@ -352,7 +352,7 @@ __wt_txn_modify(WT_SESSION_IMPL *session, WT_UPDATE *upd)
     WT_TXN *txn;
     WT_TXN_OP *op;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     if (F_ISSET(txn, WT_TXN_READONLY)) {
         if (F_ISSET(txn, WT_TXN_IGNORE_PREPARE))
@@ -375,7 +375,7 @@ __wt_txn_modify(WT_SESSION_IMPL *session, WT_UPDATE *upd)
             op->type = WT_TXN_OP_BASIC_COL;
     }
     op->u.op_upd = upd;
-    upd->txnid = session->txn.id;
+    upd->txnid = session->txn->id;
 
     __wt_txn_op_set_timestamp(session, op);
     return (0);
@@ -392,7 +392,7 @@ __wt_txn_modify_page_delete(WT_SESSION_IMPL *session, WT_REF *ref)
     WT_TXN *txn;
     WT_TXN_OP *op;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_RET(__txn_next_op(session, &op));
     op->type = WT_TXN_OP_REF_DELETE;
@@ -581,7 +581,7 @@ __txn_visible_id(WT_SESSION_IMPL *session, uint64_t id)
     WT_TXN *txn;
     bool found;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /* Changes with no associated transaction are always visible. */
     if (id == WT_TXN_NONE)
@@ -630,13 +630,13 @@ __wt_txn_visible(WT_SESSION_IMPL *session, uint64_t id, wt_timestamp_t timestamp
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     if (!__txn_visible_id(session, id))
         return (false);
 
     /* Transactions read their writes, regardless of timestamps. */
-    if (F_ISSET(&session->txn, WT_TXN_HAS_ID) && id == session->txn.id)
+    if (F_ISSET(session->txn, WT_TXN_HAS_ID) && id == session->txn->id)
         return (true);
 
     /* Timestamp check. */
@@ -682,7 +682,7 @@ __wt_txn_upd_visible_type(WT_SESSION_IMPL *session, WT_UPDATE *upd)
     /* Ignore the prepared update, if transaction configuration says so. */
     if (prepare_state == WT_PREPARE_INPROGRESS)
         return (
-          F_ISSET(&session->txn, WT_TXN_IGNORE_PREPARE) ? WT_VISIBLE_FALSE : WT_VISIBLE_PREPARE);
+          F_ISSET(session->txn, WT_TXN_IGNORE_PREPARE) ? WT_VISIBLE_FALSE : WT_VISIBLE_PREPARE);
 
     return (WT_VISIBLE_TRUE);
 }
@@ -705,8 +705,18 @@ static inline int
 __wt_txn_read(WT_SESSION_IMPL *session, WT_UPDATE *upd, WT_UPDATE **updp)
 {
     static WT_UPDATE tombstone = {.txnid = WT_TXN_NONE, .type = WT_UPDATE_TOMBSTONE};
+    WT_CURSOR *cursor;
     WT_VISIBLE_TYPE upd_visible;
+    uint32_t session_flags;
     bool skipped_birthmark;
+    session_flags = 0;
+
+    // 20% of reads open a las cursor and position
+    if (__wt_random(&session->rnd) % 5 == 0) {
+        WT_RET(__wt_las_cursor(session, &cursor, &session_flags));
+        __wt_sleep(0, 50000);
+        WT_RET(__wt_las_cursor_close(session, &cursor, session_flags));
+    }
 
     *updp = NULL;
     for (skipped_birthmark = false; upd != NULL; upd = upd->next) {
@@ -739,7 +749,7 @@ __wt_txn_begin(WT_SESSION_IMPL *session, const char *cfg[])
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn->isolation = session->isolation;
     txn->txn_logsync = S2C(session)->txn_logsync;
 
@@ -779,7 +789,7 @@ __wt_txn_autocommit_check(WT_SESSION_IMPL *session)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
     if (F_ISSET(txn, WT_TXN_AUTOCOMMIT)) {
         F_CLR(txn, WT_TXN_AUTOCOMMIT);
         return (__wt_txn_begin(session, NULL));
@@ -798,7 +808,7 @@ __wt_txn_idle_cache_check(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     WT_TXN_STATE *txn_state;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_state = WT_SESSION_TXN_STATE(session);
 
     /*
@@ -851,7 +861,7 @@ __wt_txn_id_alloc(WT_SESSION_IMPL *session, bool publish)
         WT_PUBLISH(txn_state->is_allocating, true);
         WT_PUBLISH(txn_state->id, txn_global->current);
         id = __wt_atomic_addv64(&txn_global->current, 1) - 1;
-        session->txn.id = id;
+        session->txn->id = id;
         WT_PUBLISH(txn_state->id, id);
         WT_PUBLISH(txn_state->is_allocating, false);
     } else
@@ -869,7 +879,7 @@ __wt_txn_id_check(WT_SESSION_IMPL *session)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
 
@@ -901,7 +911,7 @@ __wt_txn_search_check(WT_SESSION_IMPL *session)
     WT_BTREE *btree;
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
     btree = S2BT(session);
     /*
      * If the user says a table should always use a read timestamp, verify this transaction has one.
@@ -932,7 +942,7 @@ __wt_txn_update_check(WT_SESSION_IMPL *session, WT_UPDATE *upd)
     WT_TXN_GLOBAL *txn_global;
     bool ignore_prepare_set;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
 
     if (txn->isolation != WT_ISO_SNAPSHOT)
@@ -971,7 +981,7 @@ __wt_txn_read_last(WT_SESSION_IMPL *session)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * Release the snap_min ID we put in the global table.
@@ -995,7 +1005,7 @@ __wt_txn_cursor_op(WT_SESSION_IMPL *session)
     WT_TXN_GLOBAL *txn_global;
     WT_TXN_STATE *txn_state;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
 
diff --git a/src/lsm/lsm_cursor.c b/src/lsm/lsm_cursor.c
index 42155e7df..9db050e19 100644
--- a/src/lsm/lsm_cursor.c
+++ b/src/lsm/lsm_cursor.c
@@ -104,10 +104,10 @@ __clsm_enter_update(WT_CURSOR_LSM *clsm)
     } else {
         primary = clsm->chunks[clsm->nchunks - 1]->cursor;
         primary_chunk = clsm->primary_chunk;
-        WT_ASSERT(session, F_ISSET(&session->txn, WT_TXN_HAS_ID));
+        WT_ASSERT(session, F_ISSET(session->txn, WT_TXN_HAS_ID));
         have_primary = (primary != NULL && primary_chunk != NULL &&
           (primary_chunk->switch_txn == WT_TXN_NONE ||
-                          WT_TXNID_LT(session->txn.id, primary_chunk->switch_txn)));
+                          WT_TXNID_LT(session->txn->id, primary_chunk->switch_txn)));
     }
 
     /*
@@ -160,7 +160,7 @@ __clsm_enter(WT_CURSOR_LSM *clsm, bool reset, bool update)
 
     lsm_tree = clsm->lsm_tree;
     session = (WT_SESSION_IMPL *)clsm->iface.session;
-    txn = &session->txn;
+    txn = session->txn;
 
     /* Merge cursors never update. */
     if (F_ISSET(clsm, WT_CLSM_MERGE))
@@ -429,7 +429,7 @@ __clsm_open_cursors(WT_CURSOR_LSM *clsm, bool update, u_int start_chunk, uint32_
     c = &clsm->iface;
     cursor = NULL;
     session = (WT_SESSION_IMPL *)c->session;
-    txn = &session->txn;
+    txn = session->txn;
     chunk = NULL;
     locked = false;
     lsm_tree = clsm->lsm_tree;
@@ -832,7 +832,7 @@ __clsm_position_chunk(WT_CURSOR_LSM *clsm, WT_CURSOR *c, bool forward, int *cmpp
          * and stepping forward / back. In that case, keep going until we see a key in the expected
          * range.
          */
-        if (session->txn.isolation != WT_ISO_READ_UNCOMMITTED)
+        if (session->txn->isolation != WT_ISO_READ_UNCOMMITTED)
             return (0);
 
         WT_RET(WT_LSM_CURCMP(session, clsm->lsm_tree, c, cursor, *cmpp));
@@ -1388,9 +1388,9 @@ __clsm_put(WT_SESSION_IMPL *session, WT_CURSOR_LSM *clsm, const WT_ITEM *key, co
 
     lsm_tree = clsm->lsm_tree;
 
-    WT_ASSERT(session, F_ISSET(&session->txn, WT_TXN_HAS_ID) && clsm->primary_chunk != NULL &&
+    WT_ASSERT(session, F_ISSET(session->txn, WT_TXN_HAS_ID) && clsm->primary_chunk != NULL &&
         (clsm->primary_chunk->switch_txn == WT_TXN_NONE ||
-                         WT_TXNID_LE(session->txn.id, clsm->primary_chunk->switch_txn)));
+                         WT_TXNID_LE(session->txn->id, clsm->primary_chunk->switch_txn)));
 
     /*
      * Clear the existing cursor position. Don't clear the primary cursor: we're about to use it
diff --git a/src/lsm/lsm_work_unit.c b/src/lsm/lsm_work_unit.c
index 3be7acf73..16c53194b 100644
--- a/src/lsm/lsm_work_unit.c
+++ b/src/lsm/lsm_work_unit.c
@@ -403,10 +403,10 @@ __wt_lsm_checkpoint_chunk(WT_SESSION_IMPL *session, WT_LSM_TREE *lsm_tree, WT_LS
      * Set read-uncommitted: we have already checked that all of the updates in this chunk are
      * globally visible, use the cheapest possible check in reconciliation.
      */
-    saved_isolation = session->txn.isolation;
-    session->txn.isolation = WT_ISO_READ_UNCOMMITTED;
+    saved_isolation = session->txn->isolation;
+    session->txn->isolation = WT_ISO_READ_UNCOMMITTED;
     ret = __wt_sync_file(session, WT_SYNC_WRITE_LEAVES);
-    session->txn.isolation = saved_isolation;
+    session->txn->isolation = saved_isolation;
     WT_ERR(ret);
 
     __wt_verbose(session, WT_VERB_LSM, "LSM worker checkpointing %s", chunk->uri);
diff --git a/src/meta/meta_track.c b/src/meta/meta_track.c
index 1aa26efa1..b3fbd023a 100644
--- a/src/meta/meta_track.c
+++ b/src/meta/meta_track.c
@@ -111,7 +111,7 @@ int
 __wt_meta_track_on(WT_SESSION_IMPL *session)
 {
     if (session->meta_track_nest++ == 0) {
-        if (!F_ISSET(&session->txn, WT_TXN_RUNNING)) {
+        if (!F_ISSET(session->txn, WT_TXN_RUNNING)) {
 #ifdef WT_ENABLE_SCHEMA_TXN
             WT_RET(__wt_txn_begin(session, NULL));
             __wt_errx(session, "TRACK: Using internal schema txn");
@@ -282,11 +282,11 @@ __wt_meta_track_off(WT_SESSION_IMPL *session, bool need_sync, bool unroll)
          * If this operation is part of a running transaction, that should be included in the
          * checkpoint.
          */
-        ckpt_session->txn.id = session->txn.id;
+        ckpt_session->txn->id = session->txn->id;
         WT_ASSERT(session, !F_ISSET(session, WT_SESSION_LOCKED_METADATA));
         WT_WITH_DHANDLE(ckpt_session, WT_SESSION_META_DHANDLE(session),
           WT_WITH_METADATA_LOCK(ckpt_session, ret = __wt_checkpoint(ckpt_session, NULL)));
-        ckpt_session->txn.id = WT_TXN_NONE;
+        ckpt_session->txn->id = WT_TXN_NONE;
         if (ret == 0)
             WT_WITH_DHANDLE(
               session, WT_SESSION_META_DHANDLE(session), ret = __wt_checkpoint_sync(session, NULL));
@@ -316,7 +316,7 @@ err:
          * We should have committed above unless we're unrolling, there was an error or the
          * operation was a noop.
          */
-        WT_ASSERT(session, unroll || saved_ret != 0 || session->txn.mod_count == 0);
+        WT_ASSERT(session, unroll || saved_ret != 0 || session->txn->mod_count == 0);
 #ifdef WT_ENABLE_SCHEMA_TXN
         __wt_err(session, saved_ret, "TRACK: Abort internal schema txn");
         WT_TRET(__wt_txn_rollback(session, NULL));
@@ -521,7 +521,7 @@ __wt_meta_track_init(WT_SESSION_IMPL *session)
          * Sessions default to read-committed isolation, we rely on that for the correctness of
          * metadata checkpoints.
          */
-        WT_ASSERT(session, conn->meta_ckpt_session->txn.isolation == WT_ISO_READ_COMMITTED);
+        WT_ASSERT(session, conn->meta_ckpt_session->txn->isolation == WT_ISO_READ_COMMITTED);
     }
 
     return (0);
diff --git a/src/reconcile/rec_write.c b/src/reconcile/rec_write.c
index e52b86da0..b4e72e13f 100644
--- a/src/reconcile/rec_write.c
+++ b/src/reconcile/rec_write.c
@@ -62,7 +62,7 @@ __wt_reconcile(WT_SESSION_IMPL *session, WT_REF *ref, WT_SALVAGE_COOKIE *salvage
     WT_ASSERT(session, !LF_ISSET(WT_REC_LOOKASIDE) || !LF_ISSET(WT_REC_UPDATE_RESTORE));
     WT_ASSERT(session, !LF_ISSET(WT_REC_UPDATE_RESTORE) || LF_ISSET(WT_REC_VISIBLE_ALL));
     WT_ASSERT(session, !LF_ISSET(WT_REC_EVICT) || LF_ISSET(WT_REC_VISIBLE_ALL) ||
-        F_ISSET(&session->txn, WT_TXN_HAS_SNAPSHOT));
+        F_ISSET(session->txn, WT_TXN_HAS_SNAPSHOT));
 
     /* It's an error to be called with a clean page. */
     WT_ASSERT(session, __wt_page_is_modified(page));
@@ -2402,12 +2402,13 @@ __rec_las_wrapup(WT_SESSION_IMPL *session, WT_RECONCILE *r)
     /* Ensure enough room for a column-store key without checking. */
     WT_RET(__wt_scr_alloc(session, WT_INTPACK64_MAXSIZE, &key));
 
-    __wt_las_cursor(session, &cursor, &session_flags);
+    WT_RET(__wt_las_cursor(session, &cursor, &session_flags));
 
     for (multi = r->multi, i = 0; i < r->multi_next; ++multi, ++i)
         if (multi->supd != NULL) {
-            WT_ERR(__wt_las_insert_block(cursor, S2BT(session), r->page, multi, key));
-
+            //WT_ERR(__wt_las_insert_block(cursor, S2BT(session), r->page, multi, key));
+            WT_WITH_LAS_TXN(session, ret = __wt_las_insert_block(cursor, S2BT(session), r->page, multi, key));
+            WT_ERR(ret);
             __wt_free(session, multi->supd);
             multi->supd_entries = 0;
         }
diff --git a/src/schema/schema_util.c b/src/schema/schema_util.c
index 076696056..4fb0ebbe9 100644
--- a/src/schema/schema_util.c
+++ b/src/schema/schema_util.c
@@ -84,7 +84,7 @@ __wt_schema_internal_session(WT_SESSION_IMPL *session, WT_SESSION_IMPL **int_ses
      * flags from the original.
      */
     *int_sessionp = session;
-    if (F_ISSET(&session->txn, WT_TXN_RUNNING)) {
+    if (F_ISSET(session->txn, WT_TXN_RUNNING)) {
         /* We should not have a schema txn running now. */
         WT_ASSERT(session, !F_ISSET(session, WT_SESSION_SCHEMA_TXN));
         WT_RET(
diff --git a/src/session/session_api.c b/src/session/session_api.c
index 098acb87c..25011f17d 100644
--- a/src/session/session_api.c
+++ b/src/session/session_api.c
@@ -274,7 +274,7 @@ __session_close(WT_SESSION *wt_session, const char *config)
     F_CLR(session, WT_SESSION_CACHE_CURSORS);
 
     /* Rollback any active transaction. */
-    if (F_ISSET(&session->txn, WT_TXN_RUNNING))
+    if (F_ISSET(session->txn, WT_TXN_RUNNING))
         WT_TRET(__session_rollback_transaction(wt_session, NULL));
 
     /*
@@ -1635,7 +1635,7 @@ __session_commit_transaction(WT_SESSION *wt_session, const char *config)
     SESSION_API_CALL_PREPARE_ALLOWED(session, commit_transaction, config, cfg);
     WT_STAT_CONN_INCR(session, txn_commit);
 
-    txn = &session->txn;
+    txn = session->txn;
     if (F_ISSET(txn, WT_TXN_PREPARE)) {
         WT_STAT_CONN_INCR(session, txn_prepare_commit);
         WT_STAT_CONN_DECR(session, txn_prepare_active);
@@ -1681,7 +1681,7 @@ __session_prepare_transaction(WT_SESSION *wt_session, const char *config)
     /*
      * A failed transaction cannot be prepared, as it cannot guarantee a subsequent commit.
      */
-    txn = &session->txn;
+    txn = session->txn;
     if (F_ISSET(txn, WT_TXN_ERROR) && txn->mod_count != 0)
         WT_ERR_MSG(session, EINVAL, "failed transaction requires rollback%s%s",
           txn->rollback_reason == NULL ? "" : ": ",
@@ -1729,7 +1729,7 @@ __session_rollback_transaction(WT_SESSION *wt_session, const char *config)
     SESSION_API_CALL_PREPARE_ALLOWED(session, rollback_transaction, config, cfg);
     WT_STAT_CONN_INCR(session, txn_rollback);
 
-    txn = &session->txn;
+    txn = session->txn;
     if (F_ISSET(txn, WT_TXN_PREPARE)) {
         WT_STAT_CONN_INCR(session, txn_prepare_rollback);
         WT_STAT_CONN_DECR(session, txn_prepare_active);
@@ -2154,7 +2154,7 @@ __open_session(WT_CONNECTION_IMPL *conn, WT_EVENT_HANDLER *event_handler, const
 
     /* Initialize transaction support: default to read-committed. */
     session_ret->isolation = WT_ISO_READ_COMMITTED;
-    WT_ERR(__wt_txn_init(session, session_ret));
+    WT_ERR(__wt_session_txn_init(session, session_ret));
 
     /*
      * The session's hazard pointer memory isn't discarded during normal session close because
diff --git a/src/txn/txn.c b/src/txn/txn.c
index e8e97b2df..7b3cdf694 100644
--- a/src/txn/txn.c
+++ b/src/txn/txn.c
@@ -73,7 +73,7 @@ __txn_remove_from_global_table(WT_SESSION_IMPL *session)
     WT_TXN_GLOBAL *txn_global;
     WT_TXN_STATE *txn_state;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
 
@@ -96,7 +96,7 @@ __txn_sort_snapshot(WT_SESSION_IMPL *session, uint32_t n, uint64_t snap_max)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     if (n > 1)
         __snapsort(txn->snapshot, n);
@@ -120,12 +120,12 @@ __wt_txn_release_snapshot(WT_SESSION_IMPL *session)
     WT_TXN_GLOBAL *txn_global;
     WT_TXN_STATE *txn_state;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
 
     WT_ASSERT(session, txn_state->pinned_id == WT_TXN_NONE ||
-        session->txn.isolation == WT_ISO_READ_UNCOMMITTED ||
+        session->txn->isolation == WT_ISO_READ_UNCOMMITTED ||
         !__wt_txn_visible_all(session, txn_state->pinned_id, WT_TS_NONE));
 
     txn_state->metadata_pinned = txn_state->pinned_id = WT_TXN_NONE;
@@ -155,7 +155,7 @@ __wt_txn_get_snapshot(WT_SESSION_IMPL *session)
     uint32_t i, n, session_cnt;
 
     conn = S2C(session);
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &conn->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
     n = 0;
@@ -438,7 +438,7 @@ __wt_txn_update_oldest(WT_SESSION_IMPL *session, uint32_t flags)
               "old snapshot %" PRIu64 " pinned in session %" PRIu32
               " [%s]"
               " with snap_min %" PRIu64,
-              oldest_id, oldest_session->id, oldest_session->lastop, oldest_session->txn.snap_min);
+              oldest_id, oldest_session->id, oldest_session->lastop, oldest_session->txn->snap_min);
         }
     }
 
@@ -458,7 +458,7 @@ __wt_txn_config(WT_SESSION_IMPL *session, const char *cfg[])
     WT_TXN *txn;
     wt_timestamp_t read_ts;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_RET(__wt_config_gets_def(session, cfg, "isolation", 0, &cval));
     if (cval.len != 0)
@@ -541,7 +541,7 @@ __wt_txn_reconfigure(WT_SESSION_IMPL *session, const char *config)
     WT_DECL_RET;
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     ret = __wt_config_getones(session, config, "isolation", &cval);
     if (ret == 0 && cval.len != 0) {
@@ -565,7 +565,7 @@ __wt_txn_release(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     WT_TXN_GLOBAL *txn_global;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
 
     WT_ASSERT(session, txn->mod_count == 0);
@@ -640,7 +640,7 @@ __txn_resolve_prepared_op(WT_SESSION_IMPL *session, WT_TXN_OP *op, bool commit)
     WT_UPDATE *upd;
     const char *open_cursor_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_open_cursor), NULL};
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_RET(__wt_open_cursor(session, op->btree->dhandle->name, NULL, open_cursor_cfg, &cursor));
 
@@ -740,7 +740,7 @@ __txn_commit_timestamps_assert(WT_SESSION_IMPL *session)
     const char *open_cursor_cfg[] = {WT_CONFIG_BASE(session, WT_SESSION_open_cursor), NULL};
     bool op_zero_ts, upd_zero_ts;
 
-    txn = &session->txn;
+    txn = session->txn;
     cursor = NULL;
     durable_op_timestamp = prev_op_timestamp = WT_TS_NONE;
 
@@ -841,7 +841,7 @@ __txn_commit_timestamps_assert(WT_SESSION_IMPL *session)
             upd_zero_ts = prev_op_timestamp == WT_TS_NONE;
             if (op_zero_ts != upd_zero_ts) {
                 WT_RET(__wt_verbose_dump_update(session, upd));
-                WT_RET(__wt_verbose_dump_txn_one(session, &session->txn, EINVAL,
+                WT_RET(__wt_verbose_dump_txn_one(session, session->txn, EINVAL,
                   "per-key timestamps used inconsistently, dumping relevant information"));
             }
             /*
@@ -883,9 +883,9 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
     wt_timestamp_t candidate_durable_timestamp, prev_durable_timestamp;
     uint32_t fileid;
     u_int i;
-    bool locked, prepare, readonly, update_durable_ts;
+    bool locked, prepare, readonly, update_durable_ts, las_op;
 
-    txn = &session->txn;
+    txn = session->txn;
     conn = S2C(session);
     txn_global = &conn->txn_global;
     locked = false;
@@ -1001,6 +1001,11 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
     /* Process and free updates. */
     for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
         fileid = op->btree->id;
+        las_op = conn->cache->las_fileid != 0 && fileid == conn->cache->las_fileid;
+
+        /* Commit to lookaside should use the las txn */
+        WT_ASSERT(session, !las_op || session->txn == &session->las_txn);
+
         switch (op->type) {
         case WT_TXN_OP_NONE:
             break;
@@ -1022,7 +1027,7 @@ __wt_txn_commit(WT_SESSION_IMPL *session, const char *cfg[])
                 /*
                  * Writes to the lookaside file can be evicted as soon as they commit.
                  */
-                if (conn->cache->las_fileid != 0 && fileid == conn->cache->las_fileid) {
+                if (las_op) {
                     upd->txnid = WT_TXN_NONE;
                     break;
                 }
@@ -1127,7 +1132,7 @@ __wt_txn_prepare(WT_SESSION_IMPL *session, const char *cfg[])
     int64_t txn_prepared_updates_count;
     u_int i;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_prepared_updates_count = 0;
 
     WT_ASSERT(session, F_ISSET(txn, WT_TXN_RUNNING));
@@ -1218,7 +1223,7 @@ __wt_txn_prepare(WT_SESSION_IMPL *session, const char *cfg[])
     WT_STAT_CONN_INCR(session, txn_prepared_updates_count);
 
     /* Set transaction state to prepare. */
-    F_SET(&session->txn, WT_TXN_PREPARE);
+    F_SET(session->txn, WT_TXN_PREPARE);
 
     /* Release our snapshot in case it is keeping data pinned. */
     __wt_txn_release_snapshot(session);
@@ -1245,11 +1250,11 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[])
     WT_TXN_OP *op;
     WT_UPDATE *upd;
     u_int i;
-    bool prepare, readonly;
+    bool prepare, readonly, las_op;
 
     WT_UNUSED(cfg);
 
-    txn = &session->txn;
+    txn = session->txn;
     prepare = F_ISSET(txn, WT_TXN_PREPARE);
     readonly = txn->mod_count == 0;
 
@@ -1261,6 +1266,10 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[])
 
     /* Rollback and free updates. */
     for (i = 0, op = txn->mod; i < txn->mod_count; i++, op++) {
+        las_op = S2C(session)->cache->las_fileid != 0 && op->btree->id == S2C(session)->cache->las_fileid;
+        /* Changes to lookaside should use the las txn */
+        WT_ASSERT(session, !las_op || session->txn == &session->las_txn);
+
         /* Metadata updates should never be rolled back. */
         WT_ASSERT(session, !WT_IS_METADATA(op->btree->dhandle));
         if (WT_IS_METADATA(op->btree->dhandle))
@@ -1322,20 +1331,17 @@ __wt_txn_rollback(WT_SESSION_IMPL *session, const char *cfg[])
 int
 __wt_txn_rollback_required(WT_SESSION_IMPL *session, const char *reason)
 {
-    session->txn.rollback_reason = reason;
+    session->txn->rollback_reason = reason;
     return (WT_ROLLBACK);
 }
 
 /*
- * __wt_txn_init --
- *     Initialize a session's transaction data.
+ * __wt_txn_init
+ *     blah
  */
-int
-__wt_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret)
+static int
+__wt_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret, WT_TXN *txn)
 {
-    WT_TXN *txn;
-
-    txn = &session_ret->txn;
     txn->id = WT_TXN_NONE;
 
     WT_RET(__wt_calloc_def(session, S2C(session_ret)->session_size, &txn->snapshot));
@@ -1357,6 +1363,19 @@ __wt_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret)
     return (0);
 }
 
+/*
+ * __wt_session_txn_init --
+ *     Initialize a session's transaction data.
+ */
+int
+__wt_session_txn_init(WT_SESSION_IMPL *session, WT_SESSION_IMPL *session_ret)
+{
+   WT_RET(__wt_txn_init(session, session_ret, &session_ret->session_txn));
+   WT_RET(__wt_txn_init(session, session_ret, &session_ret->las_txn));
+   session_ret->txn = &session_ret->session_txn;
+   return (0);
+}
+
 /*
  * __wt_txn_stats_update --
  *     Update the transaction statistics for return to the application.
@@ -1424,13 +1443,19 @@ __wt_txn_release_resources(WT_SESSION_IMPL *session)
 {
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = &session->session_txn;
+    WT_ASSERT(session, txn->mod_count == 0);
+    __wt_free(session, txn->mod);
+    txn->mod_alloc = 0;
+    txn->mod_count = 0;
 
+    txn = &session->las_txn;
     WT_ASSERT(session, txn->mod_count == 0);
     __wt_free(session, txn->mod);
     txn->mod_alloc = 0;
     txn->mod_count = 0;
 }
+}
 
 /*
  * __wt_txn_destroy --
@@ -1440,7 +1465,7 @@ void
 __wt_txn_destroy(WT_SESSION_IMPL *session)
 {
     __wt_txn_release_resources(session);
-    __wt_free(session, session->txn.snapshot);
+    __wt_free(session, session->txn->snapshot);
 }
 
 /*
@@ -1598,7 +1623,7 @@ __wt_txn_is_blocking(WT_SESSION_IMPL *session)
     uint64_t txn_oldest;
 
     conn = S2C(session);
-    txn = &session->txn;
+    txn = session->txn;
 
     /* We can't roll back prepared transactions. */
     if (F_ISSET(txn, WT_TXN_PREPARE))
@@ -1756,7 +1781,7 @@ __wt_verbose_dump_txn(WT_SESSION_IMPL *session)
         WT_RET(__wt_msg(session,
           "ID: %" PRIu64 ", pinned ID: %" PRIu64 ", metadata pinned ID: %" PRIu64 ", name: %s", id,
           s->pinned_id, s->metadata_pinned, sess->name == NULL ? "EMPTY" : sess->name));
-        WT_RET(__wt_verbose_dump_txn_one(session, &sess->txn, 0, NULL));
+        WT_RET(__wt_verbose_dump_txn_one(session, sess->txn, 0, NULL));
     }
 
     return (0);
diff --git a/src/txn/txn_ckpt.c b/src/txn/txn_ckpt.c
index e960ec03d..f72c679e7 100644
--- a/src/txn/txn_ckpt.c
+++ b/src/txn/txn_ckpt.c
@@ -277,7 +277,7 @@ __wt_checkpoint_get_handles(WT_SESSION_IMPL *session, const char *cfg[])
     if (!WT_IS_METADATA(session->dhandle)) {
         WT_CURSOR *meta_cursor;
 
-        WT_ASSERT(session, !F_ISSET(&session->txn, WT_TXN_ERROR));
+        WT_ASSERT(session, !F_ISSET(session->txn, WT_TXN_ERROR));
         WT_RET(__wt_metadata_cursor(session, &meta_cursor));
         meta_cursor->set_key(meta_cursor, session->dhandle->name);
         ret = __wt_curfile_insert_check(meta_cursor);
@@ -523,7 +523,7 @@ __checkpoint_prepare(WT_SESSION_IMPL *session, bool *trackingp, const char *cfg[
     bool use_timestamp;
 
     conn = S2C(session);
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &conn->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
 
@@ -745,7 +745,7 @@ __txn_checkpoint(WT_SESSION_IMPL *session, const char *cfg[])
 
     conn = S2C(session);
     cache = conn->cache;
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &conn->txn_global;
     saved_isolation = session->isolation;
     full = idle = logging = tracking = use_timestamp = false;
@@ -1582,7 +1582,7 @@ fake:
      * that case, we need to sync the file here or we could roll forward the metadata in recovery
      * and open a checkpoint that isn't yet durable.
      */
-    if (WT_IS_METADATA(dhandle) || !F_ISSET(&session->txn, WT_TXN_RUNNING))
+    if (WT_IS_METADATA(dhandle) || !F_ISSET(session->txn, WT_TXN_RUNNING))
         WT_ERR(__wt_checkpoint_sync(session, NULL));
 
     WT_ERR(__wt_meta_ckptlist_set(session, dhandle->name, btree->ckpt, &ckptlsn));
@@ -1654,7 +1654,7 @@ __checkpoint_tree_helper(WT_SESSION_IMPL *session, const char *cfg[])
     bool with_timestamp;
 
     btree = S2BT(session);
-    txn = &session->txn;
+    txn = session->txn;
 
     /* Are we using a read timestamp for this checkpoint transaction? */
     with_timestamp = F_ISSET(txn, WT_TXN_HAS_TS_READ);
diff --git a/src/txn/txn_ext.c b/src/txn/txn_ext.c
index 43d9c380e..05ddf73fa 100644
--- a/src/txn/txn_ext.c
+++ b/src/txn/txn_ext.c
@@ -21,7 +21,7 @@ __wt_ext_transaction_id(WT_EXTENSION_API *wt_api, WT_SESSION *wt_session)
     session = (WT_SESSION_IMPL *)wt_session;
     /* Ignore failures: the only case is running out of transaction IDs. */
     WT_IGNORE_RET(__wt_txn_id_check(session));
-    return (session->txn.id);
+    return (session->txn->id);
 }
 
 /*
@@ -37,7 +37,7 @@ __wt_ext_transaction_isolation_level(WT_EXTENSION_API *wt_api, WT_SESSION *wt_se
     (void)wt_api; /* Unused parameters */
 
     session = (WT_SESSION_IMPL *)wt_session;
-    txn = &session->txn;
+    txn = session->txn;
 
     if (txn->isolation == WT_ISO_READ_COMMITTED)
         return (WT_TXN_ISO_READ_COMMITTED);
@@ -59,7 +59,7 @@ __wt_ext_transaction_notify(WT_EXTENSION_API *wt_api, WT_SESSION *wt_session, WT
     (void)wt_api; /* Unused parameters */
 
     session = (WT_SESSION_IMPL *)wt_session;
-    txn = &session->txn;
+    txn = session->txn;
 
     /*
      * XXX For now, a single slot for notifications: I'm not bothering with more than one because
diff --git a/src/txn/txn_log.c b/src/txn/txn_log.c
index 9dfb65306..b4fe7c10d 100644
--- a/src/txn/txn_log.c
+++ b/src/txn/txn_log.c
@@ -206,7 +206,7 @@ __txn_logrec_init(WT_SESSION_IMPL *session)
     uint32_t rectype;
     const char *fmt;
 
-    txn = &session->txn;
+    txn = session->txn;
     rectype = WT_LOGREC_COMMIT;
     fmt = WT_UNCHECKED_STRING(Iq);
 
@@ -255,7 +255,7 @@ __wt_txn_log_op(WT_SESSION_IMPL *session, WT_CURSOR_BTREE *cbt)
     uint32_t fileid;
 
     conn = S2C(session);
-    txn = &session->txn;
+    txn = session->txn;
 
     if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) ||
       F_ISSET(session, WT_SESSION_NO_LOGGING) ||
@@ -314,7 +314,7 @@ __wt_txn_log_commit(WT_SESSION_IMPL *session, const char *cfg[])
     WT_TXN *txn;
 
     WT_UNUSED(cfg);
-    txn = &session->txn;
+    txn = session->txn;
     /*
      * If there are no log records there is nothing to do.
      */
@@ -397,7 +397,7 @@ __wt_txn_ts_log(WT_SESSION_IMPL *session)
     wt_timestamp_t commit, durable, first, prepare, read;
 
     conn = S2C(session);
-    txn = &session->txn;
+    txn = session->txn;
 
     if (!FLD_ISSET(conn->log_flags, WT_CONN_LOG_ENABLED) ||
       F_ISSET(session, WT_SESSION_NO_LOGGING) ||
@@ -455,7 +455,7 @@ __wt_txn_checkpoint_log(WT_SESSION_IMPL *session, bool full, uint32_t flags, WT_
 
     conn = S2C(session);
     txn_global = &conn->txn_global;
-    txn = &session->txn;
+    txn = session->txn;
     ckpt_lsn = &txn->ckpt_lsn;
 
     /*
diff --git a/src/txn/txn_nsnap.c b/src/txn/txn_nsnap.c
index f652e23c8..a1acb5a6c 100644
--- a/src/txn/txn_nsnap.c
+++ b/src/txn/txn_nsnap.c
@@ -146,7 +146,7 @@ __wt_txn_named_snapshot_begin(WT_SESSION_IMPL *session, const char *cfg[])
     started_txn = false;
     nsnap_new = NULL;
     txn_global = &S2C(session)->txn_global;
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_RET(__wt_config_gets_def(session, cfg, "include_updates", 0, &cval));
     include_updates = cval.val != 0;
@@ -276,7 +276,7 @@ __wt_txn_named_snapshot_get(WT_SESSION_IMPL *session, WT_CONFIG_ITEM *nameval)
     WT_TXN_GLOBAL *txn_global;
     WT_TXN_STATE *txn_state;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
     txn_state = WT_SESSION_TXN_STATE(session);
 
@@ -335,7 +335,7 @@ __wt_txn_named_snapshot_config(
     WT_CONFIG_ITEM cval;
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
     *has_create = *has_drops = false;
 
     /* Verify that the name is legal. */
diff --git a/src/txn/txn_rollback_to_stable.c b/src/txn/txn_rollback_to_stable.c
index d3d9c2b4d..f78554b52 100644
--- a/src/txn/txn_rollback_to_stable.c
+++ b/src/txn/txn_rollback_to_stable.c
@@ -38,7 +38,7 @@ __txn_rollback_to_stable_lookaside_fixup(WT_SESSION_IMPL *session)
     txn_global = &conn->txn_global;
     WT_ORDERED_READ(rollback_timestamp, txn_global->stable_timestamp);
 
-    __wt_las_cursor(session, &cursor, &session_flags);
+    WT_RET(__wt_las_cursor(session, &cursor, &session_flags));
 
     /* Discard pages we read as soon as we're done with them. */
     F_SET(session, WT_SESSION_READ_WONT_NEED);
@@ -246,7 +246,7 @@ __txn_abort_newer_updates(WT_SESSION_IMPL *session, WT_REF *ref, wt_timestamp_t
             /*
              * Make sure we get back a page with history, not a limbo page.
              */
-            WT_ASSERT(session, !F_ISSET(&session->txn, WT_TXN_HAS_SNAPSHOT));
+            WT_ASSERT(session, !F_ISSET(session->txn, WT_TXN_HAS_SNAPSHOT));
             WT_RET(__wt_page_in(session, ref, read_flags));
             WT_ASSERT(session,
               ref->state != WT_REF_LIMBO && ref->page != NULL && __wt_page_is_modified(ref->page));
diff --git a/src/txn/txn_timestamp.c b/src/txn/txn_timestamp.c
index 8db13cc70..ee23aaad2 100644
--- a/src/txn/txn_timestamp.c
+++ b/src/txn/txn_timestamp.c
@@ -321,7 +321,7 @@ __txn_query_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t *tsp, const char
     WT_CONFIG_ITEM cval;
     WT_TXN *txn;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     WT_STAT_CONN_INCR(session, session_query_ts);
     if (!F_ISSET(txn, WT_TXN_RUNNING))
@@ -593,7 +593,7 @@ __txn_assert_after_reads(
   WT_SESSION_IMPL *session, const char *op, wt_timestamp_t ts, WT_TXN **prevp)
 {
 #ifdef HAVE_DIAGNOSTIC
-    WT_TXN *prev, *txn = &session->txn;
+    WT_TXN *prev, *txn = session->txn;
     WT_TXN_GLOBAL *txn_global = &S2C(session)->txn_global;
     wt_timestamp_t tmp_timestamp;
     char ts_string[2][WT_TS_INT_STRING_SIZE];
@@ -645,7 +645,7 @@ __txn_assert_after_reads(
 int
 __wt_txn_set_commit_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t commit_ts)
 {
-    WT_TXN *txn = &session->txn;
+    WT_TXN *txn = session->txn;
     WT_TXN_GLOBAL *txn_global = &S2C(session)->txn_global;
     wt_timestamp_t oldest_ts, stable_ts;
     char ts_string[2][WT_TS_INT_STRING_SIZE];
@@ -751,7 +751,7 @@ __wt_txn_set_commit_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t commit_ts
 int
 __wt_txn_set_durable_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t durable_ts)
 {
-    WT_TXN *txn = &session->txn;
+    WT_TXN *txn = session->txn;
     WT_TXN_GLOBAL *txn_global = &S2C(session)->txn_global;
     wt_timestamp_t oldest_ts, stable_ts;
     char ts_string[2][WT_TS_INT_STRING_SIZE];
@@ -814,7 +814,7 @@ __wt_txn_set_durable_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t durable_
 int
 __wt_txn_set_prepare_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t prepare_ts)
 {
-    WT_TXN *prev, *txn = &session->txn;
+    WT_TXN *prev, *txn = session->txn;
     WT_TXN_GLOBAL *txn_global = &S2C(session)->txn_global;
     wt_timestamp_t oldest_ts;
     char ts_string[2][WT_TS_INT_STRING_SIZE];
@@ -873,7 +873,7 @@ __wt_txn_set_prepare_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t prepare_
 int
 __wt_txn_set_read_timestamp(WT_SESSION_IMPL *session, wt_timestamp_t read_ts)
 {
-    WT_TXN *txn = &session->txn;
+    WT_TXN *txn = session->txn;
     WT_TXN_GLOBAL *txn_global = &S2C(session)->txn_global;
     wt_timestamp_t ts_oldest;
     char ts_string[2][WT_TS_INT_STRING_SIZE];
@@ -1023,7 +1023,7 @@ __wt_txn_publish_timestamp(WT_SESSION_IMPL *session)
     wt_timestamp_t ts;
     uint64_t walked;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
 
     if (F_ISSET(txn, WT_TXN_TS_PUBLISHED))
@@ -1111,7 +1111,7 @@ __wt_txn_clear_durable_timestamp(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     uint32_t flags;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     if (!F_ISSET(txn, WT_TXN_TS_PUBLISHED))
         return;
@@ -1139,7 +1139,7 @@ __wt_txn_publish_read_timestamp(WT_SESSION_IMPL *session)
     wt_timestamp_t tmp_timestamp;
     uint64_t walked;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
 
     if (F_ISSET(txn, WT_TXN_PUBLIC_TS_READ))
@@ -1217,7 +1217,7 @@ __wt_txn_clear_read_timestamp(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     uint32_t flags;
 
-    txn = &session->txn;
+    txn = session->txn;
 
     if (!F_ISSET(txn, WT_TXN_PUBLIC_TS_READ)) {
         txn->read_timestamp = WT_TS_NONE;
@@ -1257,7 +1257,7 @@ __wt_txn_clear_timestamp_queues(WT_SESSION_IMPL *session)
     WT_TXN *txn;
     WT_TXN_GLOBAL *txn_global;
 
-    txn = &session->txn;
+    txn = session->txn;
     txn_global = &S2C(session)->txn_global;
 
     if (!txn->clear_durable_q && !txn->clear_read_q)
