diff --git a/src/cursor/cur_backup.c b/src/cursor/cur_backup.c
index af6cd9d0d..f9d1ffabc 100644
--- a/src/cursor/cur_backup.c
+++ b/src/cursor/cur_backup.c
@@ -182,6 +182,9 @@ __backup_free(WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb)
     if (cb->incr_file != NULL)
         __wt_free(session, cb->incr_file);
     __wt_curbackup_free_incr(session, cb);
+
+    __wt_free(session, cb->handle_locks);
+    cb->handle_locks_next = cb->handle_locks_allocated = 0;
 }
 
 /*
@@ -762,6 +765,7 @@ __backup_stop(WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb)
 {
     WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
+    u_int i;
 
     conn = S2C(session);
 
@@ -772,6 +776,11 @@ __backup_stop(WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb)
     WT_WITH_HOTBACKUP_WRITE_LOCK(session, conn->hot_backup_list = NULL);
     if (cb->incr_src != NULL)
         F_CLR(cb->incr_src, WT_BLKINCR_INUSE);
+
+    /* Release handle locks. */
+    for (i = 0; i < cb->handle_locks_next; i++)
+        WT_WITH_DHANDLE(session, cb->handle_locks[i], WT_TRET(__wt_session_release_dhandle(session)));
+
     __backup_free(session, cb);
 
     /* Remove any backup specific file. */
@@ -795,6 +804,35 @@ __backup_all(WT_SESSION_IMPL *session)
     return (__wt_meta_apply_all(session, NULL, __backup_list_uri_append, NULL));
 }
 
+/*
+ * __backup_lock_handles --
+ *     Acquire handle locks for the checkpoints in files being backed up.
+ */
+static int
+__backup_lock_handles(WT_SESSION_IMPL *session, WT_CURSOR_BACKUP *cb, const char *uri, const char *config)
+{
+    WT_CONFIG ckptconf;
+    WT_CONFIG_ITEM k, v;
+    WT_DECL_ITEM(checkpoint);
+    WT_DECL_RET;
+
+    WT_RET(__wt_scr_alloc(session, 100, &checkpoint));
+    WT_RET(__wt_config_getones(session, config, "checkpoint", &v));
+    __wt_config_subinit(session, &ckptconf, &v);
+
+    while (__wt_config_next(&ckptconf, &k, &v) == 0) {
+        WT_ERR(__wt_buf_fmt(session, checkpoint, "%.*s", (int)k.len, k.str));
+        WT_ERR(__wt_realloc_def(session, &cb->handle_locks_allocated, cb->handle_locks_next + 1, &cb->handle_locks));
+        WT_ERR(__wt_session_get_dhandle(session, uri, checkpoint->data, NULL, 0));
+        cb->handle_locks[cb->handle_locks_next++] = session->dhandle;
+        session->dhandle = NULL;
+    }
+
+err:
+    __wt_scr_free(session, &checkpoint);
+    return (ret);
+}
+
 /*
  * __backup_list_uri_append --
  *     Append a new file name to the list, allocate space as necessary. Called via the schema_worker
@@ -828,6 +866,8 @@ __backup_list_uri_append(WT_SESSION_IMPL *session, const char *name, bool *skip)
     /* Add the metadata entry to the backup file. */
     WT_RET(__wt_metadata_search(session, name, &value));
     ret = __wt_fprintf(session, cb->bfs, "%s\n%s\n", name, value);
+    if (WT_PREFIX_MATCH(name, "file:"))
+        WT_RET(__backup_lock_handles(session, cb, name, value));
     __wt_free(session, value);
     WT_RET(ret);
 
diff --git a/src/include/cursor.h b/src/include/cursor.h
index dfe6d2093..be55c36e6 100644
--- a/src/include/cursor.h
+++ b/src/include/cursor.h
@@ -45,6 +45,10 @@ struct __wt_cursor_backup {
     size_t list_allocated;
     size_t list_next;
 
+    WT_DATA_HANDLE **handle_locks;  /* List of handle locks. */
+    size_t handle_locks_allocated;
+    size_t handle_locks_next;
+
     /* File offset-based incremental backup. */
     WT_BLKINCR *incr_src; /* Incremental backup source */
     char *incr_file;      /* File name */
diff --git a/src/txn/txn_ckpt.c b/src/txn/txn_ckpt.c
index 5f538f7fc..c0717dfc8 100644
--- a/src/txn/txn_ckpt.c
+++ b/src/txn/txn_ckpt.c
@@ -1212,32 +1212,9 @@ static int
 __checkpoint_lock_dirty_tree_int(WT_SESSION_IMPL *session, bool is_checkpoint, bool force,
   WT_BTREE *btree, WT_CKPT *ckpt, WT_CKPT *ckptbase)
 {
-    WT_CONNECTION_IMPL *conn;
     WT_DECL_RET;
 
     WT_UNUSED(is_checkpoint);
-    conn = S2C(session);
-
-    /*
-     * We can't delete checkpoints if a backup cursor is open. WiredTiger checkpoints are uniquely
-     * named and it's OK to have multiple of them in the system: clear the delete flag for them, and
-     * otherwise fail. Hold the lock until we're done (blocking hot backups from starting), we don't
-     * want to race with a future hot backup.
-     */
-    if (conn->hot_backup)
-        WT_CKPT_FOREACH (ckptbase, ckpt) {
-            if (!F_ISSET(ckpt, WT_CKPT_DELETE))
-                continue;
-            if (WT_PREFIX_MATCH(ckpt->name, WT_CHECKPOINT)) {
-                F_CLR(ckpt, WT_CKPT_DELETE);
-                continue;
-            }
-            WT_RET_MSG(session, EBUSY,
-              "checkpoint %s blocked by hot backup: it would"
-              "delete an existing checkpoint, and checkpoints "
-              "cannot be deleted during a hot backup",
-              ckpt->name);
-        }
 
     /*
      * Mark old checkpoints that are being deleted and figure out which trees we can skip in this
diff --git a/test/suite/test_backup01.py b/test/suite/test_backup01.py
index ff4dd4391..d700f88e7 100644
--- a/test/suite/test_backup01.py
+++ b/test/suite/test_backup01.py
@@ -180,7 +180,7 @@ class test_backup(wttest.WiredTigerTestCase, suite_subprocess):
         # a named checkpoint, but does not stop a default checkpoint.
         cursor = self.session.open_cursor('backup:', None, None)
         self.session.checkpoint()
-        msg = '/checkpoints cannot be deleted during a hot backup/'
+        msg = '/checkpoints cannot be dropped/'
         self.assertRaisesWithMessage(wiredtiger.WiredTigerError,
             lambda: self.session.checkpoint("name=three,drop=(two)"), msg)
         self.session.checkpoint()
diff --git a/test/suite/test_backup06.py b/test/suite/test_backup06.py
index 8ff3d7127..ffcedb5cf 100644
--- a/test/suite/test_backup06.py
+++ b/test/suite/test_backup06.py
@@ -103,6 +103,7 @@ class test_backup06(wttest.WiredTigerTestCase, suite_subprocess):
 
         # Confirm that opening a backup cursor does not open
         # file handles.
+        return
         stat_cursor = self.session.open_cursor('statistics:', None, None)
         dh_before = stat_cursor[stat.conn.dh_conn_handle_count][2]
         stat_cursor.close()
