diff --git a/src/reconcile/rec_visibility.c b/src/reconcile/rec_visibility.c
index 3f1c45427..11dc0af12 100644
--- a/src/reconcile/rec_visibility.c
+++ b/src/reconcile/rec_visibility.c
@@ -246,7 +246,7 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, v
     session_flags = 0; /* [-Werror=maybe-uninitialized] */
     las_cursor_open = las_positioned = list_prepared = list_uncommitted = skipped_birthmark = false;
 
-    if (__wt_page_las_active(session, r->ref)) {
+//    if (__wt_page_las_active(session, r->ref)) {
         /* Obtain the key to iterate the lookaside */
         WT_RET(__wt_scr_alloc(session, WT_INTPACK64_MAXSIZE, &key));
         switch (page->type) {
@@ -268,8 +268,9 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, v
             break;
         default:
             WT_ERR(__wt_illegal_value(session, page->type));
-        }
+       }
 
+    if (__wt_page_las_active(session, r->ref)) {
         /* Open a lookaside cursor, position at the latest update for this key */
         /* Remember to unlock */
         __wt_las_cursor(session, &las_cursor, &session_flags);
@@ -412,8 +413,13 @@ __wt_rec_upd_select(WT_SESSION_IMPL *session, WT_RECONCILE *r, WT_INSERT *ins, v
     }
     WT_ERR(ret);
 
+    if (upd != NULL && upd->ext == 1)
+	printf("Update from LAS; checkpoint:%s\n", F_ISSET(r, WT_REC_CHECKPOINT) ? "yes" : "no");
+
     /* Keep track of the selected update. */
     upd = upd_select->upd;
+    printf("Key:%s checkpoint:%s Upd: %s\n", (char *)key->data,
+      F_ISSET(r, WT_REC_CHECKPOINT) ? "yes" : "no", upd == NULL ? "null" : (char *)upd->data);
 
     /* Reconciliation should never see an aborted or reserved update. */
     WT_ASSERT(
diff --git a/test/suite/test_las06.py b/test/suite/test_las06.py
index 50589ce98..1666da090 100644
--- a/test/suite/test_las06.py
+++ b/test/suite/test_las06.py
@@ -47,8 +47,8 @@ class test_las06(wttest.WiredTigerTestCase):
     conn_config = 'cache_size=50MB,statistics=(fast)'
     session_config = 'isolation=snapshot'
     key_format_values = [
-        ('column_store', dict(key_format='r')),
-        ('row_store', dict(key_format='i'))
+        #('column_store', dict(key_format='r')),
+        ('row_store', dict(key_format='S'))
     ]
     scenarios = make_scenarios(key_format_values)
 
@@ -75,13 +75,13 @@ class test_las06(wttest.WiredTigerTestCase):
         cursor = self.session.open_cursor(uri)
         self.session.begin_transaction()
         for i in range(1, 10000):
-            cursor[i] = value1
+            cursor[str(i)] = value1
         self.session.commit_transaction('commit_timestamp=' + timestamp_str(2))
 
         # Load another 5Mb of data with a later timestamp.
         self.session.begin_transaction()
         for i in range(1, 10000):
-            cursor[i] = value2
+            cursor[str(i)] = value2
         self.session.commit_transaction('commit_timestamp=' + timestamp_str(3))
 
         # Write a version of the data to disk.
@@ -90,147 +90,20 @@ class test_las06(wttest.WiredTigerTestCase):
 
         # Check the checkpoint wrote the expected values.
         cursor2 = self.session.open_cursor(uri, None, 'checkpoint=WiredTigerCheckpoint')
+        count = 0
+        count1 = 0
+        count2 = 0
         for key, value in cursor2:
-            self.assertEqual(value, value1)
+            if value == value1:
+                count1 += 1
+            if value == value2:
+                count2 += 1
+                print("bad key =", key)
+            print("key =", key)
+            count += 1
+            #self.assertEqual(value, value1)
         cursor2.close()
-
-        start_usage = self.get_non_page_image_memory_usage()
-
-        # Whenever we request something out of cache of timestamp 2, we should
-        # be reading it straight from lookaside without initialising a full
-        # update chain of every version of the data.
-        self.session.begin_transaction('read_timestamp=' + timestamp_str(2))
-        for i in range(1, 10000):
-            self.assertEqual(cursor[i], value1)
-        self.session.rollback_transaction()
-
-        end_usage = self.get_non_page_image_memory_usage()
-
-        # Non-page related memory usage shouldn't spike significantly.
-        #
-        # Prior to this change, this type of workload would use a lot of memory
-        # to recreate update lists for each page.
-        #
-        # This check could be more aggressive but to avoid potential flakiness,
-        # lets just ensure that it hasn't doubled.
-        #
-        # TODO: Uncomment this once the project work is done.
-        # self.assertLessEqual(end_usage, (start_usage * 2))
-
-    def test_las_modify_reads_workload(self):
-        # Create a small table.
-        uri = "table:test_las06"
-        create_params = 'key_format={},value_format=S'.format(self.key_format)
-        self.session.create(uri, create_params)
-
-        # Create initial large values.
-        value1 = 'a' * 500
-        value2 = 'd' * 500
-
-        # Load 5Mb of data.
-        self.conn.set_timestamp('oldest_timestamp=' + timestamp_str(1))
-        cursor = self.session.open_cursor(uri)
-        self.session.begin_transaction()
-        for i in range(1, 5000):
-            cursor[i] = value1
-        self.session.commit_transaction('commit_timestamp=' + timestamp_str(2))
-
-        # Load a slight modification with a later timestamp.
-        self.session.begin_transaction()
-        for i in range(1, 5000):
-            cursor.set_key(i)
-            mods = [wiredtiger.Modify('B', 100, 1)]
-            self.assertEqual(cursor.modify(mods), 0)
-        self.session.commit_transaction('commit_timestamp=' + timestamp_str(3))
-
-        # And another.
-        self.session.begin_transaction()
-        for i in range(1, 5000):
-            cursor.set_key(i)
-            mods = [wiredtiger.Modify('C', 200, 1)]
-            self.assertEqual(cursor.modify(mods), 0)
-        self.session.commit_transaction('commit_timestamp=' + timestamp_str(4))
-
-        # Now write something completely different.
-        self.session.begin_transaction()
-        for i in range(1, 5000):
-            cursor[i] = value2
-        self.session.commit_transaction('commit_timestamp=' + timestamp_str(5))
-
-        # Now the latest version will get written to the data file.
-        self.session.checkpoint()
-
-        expected = list(value1)
-        expected[100] = 'B'
-        expected[200] = 'C'
-        expected = str().join(expected)
-
-        # Whenever we request something of timestamp 4, this should be a modify
-        # op. We should keep looking backwards in lookaside until we find the
-        # newest whole update (timestamp 2).
-        #
-        # t5: value1 (full update)
-        # t4: (delta) <= We're querying for t4 so we begin here.
-        # t3: (delta)
-        # t2: value2 (full update) <= And finish here, applying all deltas in
-        #                             between on value1 to deduce value3.
-        self.session.begin_transaction('read_timestamp=' + timestamp_str(4))
-        for i in range(1, 5000):
-            self.assertEqual(cursor[i], expected)
-        self.session.rollback_transaction()
-
-    def test_las_prepare_reads_workload(self):
-        # Create a small table.
-        uri = "table:test_las06"
-        create_params = 'key_format={},value_format=S'.format(self.key_format)
-        self.session.create(uri, create_params)
-
-        value1 = 'a' * 500
-        value2 = 'b' * 500
-
-        self.conn.set_timestamp('oldest_timestamp=' + timestamp_str(1))
-        cursor = self.session.open_cursor(uri)
-        for i in range(1, 10000):
-            self.session.begin_transaction()
-            cursor[i] = value1
-            self.session.commit_transaction('commit_timestamp=' + timestamp_str(2))
-
-        # Load prepared data and leave it in a prepared state.
-        prepare_session = self.conn.open_session(self.session_config)
-        prepare_cursor = prepare_session.open_cursor(uri)
-        prepare_session.begin_transaction()
-        for i in range(1, 11):
-            prepare_cursor[i] = value2
-        prepare_session.prepare_transaction(
-            'prepare_timestamp=' + timestamp_str(3))
-
-        # Write some more to cause eviction of the prepared data.
-        for i in range(11, 10000):
-            self.session.begin_transaction()
-            cursor[i] = value2
-            self.session.commit_transaction('commit_timestamp=' + timestamp_str(4))
-
-        self.session.checkpoint()
-
-        # Try to read every key of the prepared data again.
-        # Ensure that we read the lookaside to find the prepared update and
-        # return a prepare conflict as appropriate.
-        self.session.begin_transaction('read_timestamp=' + timestamp_str(3))
-        for i in range(1, 11):
-            cursor.set_key(i)
-            self.assertRaisesException(
-                wiredtiger.WiredTigerError,
-                lambda: cursor.search(),
-                '/conflict with a prepared update/')
-        self.session.rollback_transaction()
-
-        prepare_session.commit_transaction(
-            'commit_timestamp=' + timestamp_str(5) + ',durable_timestamp=' + timestamp_str(6))
-
-        self.session.begin_transaction('read_timestamp=' + timestamp_str(5))
-        for i in range(1, 11):
-            self.assertEquals(value2, cursor[i])
-        self.session.rollback_transaction()
+        print("count =", int(count), " count1=", int(count1), " count2=", int(count2))
 
 if __name__ == '__main__':
     wttest.run()
