diff --git a/mutation/partition_version.cc b/mutation/partition_version.cc
index 879d9616ac..dddaab7c1d 100644
--- a/mutation/partition_version.cc
+++ b/mutation/partition_version.cc
@@ -572,15 +572,17 @@ mutation_partition partition_entry::squashed(const schema& s, is_evictable evict
         .as_mutation_partition(s);
 }
 
-void partition_entry::upgrade(schema_ptr from, schema_ptr to, mutation_cleaner& cleaner, cache_tracker* tracker)
+void partition_entry::upgrade(logalloc::region& r, schema_ptr from, schema_ptr to, mutation_cleaner& cleaner, cache_tracker* tracker)
 {
-    auto new_version = current_allocator().construct<partition_version>(squashed(from, to, is_evictable(bool(tracker))), to);
+  with_allocator(r.allocator(), [&] {
+    auto new_version = r.allocator().construct<partition_version>(squashed(from, to, is_evictable(bool(tracker))), to);
     auto old_version = &*_version;
     set_version(new_version);
     if (tracker) {
         tracker->insert(*new_version);
     }
     remove_or_mark_as_unique_owner(old_version, &cleaner);
+  });
 }
 
 partition_snapshot_ptr partition_entry::read(logalloc::region& r,
diff --git a/mutation/partition_version.hh b/mutation/partition_version.hh
index d9505dd656..fa111a5876 100644
--- a/mutation/partition_version.hh
+++ b/mutation/partition_version.hh
@@ -601,7 +601,7 @@ public:
 
     // needs to be called with reclaiming disabled
     // Must not be called when is_locked().
-    void upgrade(schema_ptr from, schema_ptr to, mutation_cleaner&, cache_tracker*);
+    void upgrade(logalloc::region& r, schema_ptr from, schema_ptr to, mutation_cleaner&, cache_tracker*);
 
     const schema_ptr& get_schema() const noexcept { return _version->get_schema(); }
 
diff --git a/replica/memtable.cc b/replica/memtable.cc
index 4a6bd5829a..3117f1b33a 100644
--- a/replica/memtable.cc
+++ b/replica/memtable.cc
@@ -840,16 +840,14 @@ bool memtable::is_flushed() const noexcept {
 
 void memtable_entry::upgrade_schema(logalloc::region& r, const schema_ptr& s, mutation_cleaner& cleaner) {
     if (schema() != s) {
-        partition().upgrade(schema(), s, cleaner, no_cache_tracker);
+        partition().upgrade(r, schema(), s, cleaner, no_cache_tracker);
     }
 }
 
 void memtable::upgrade_entry(memtable_entry& e) {
     if (e.schema() != _schema) {
         assert(!reclaiming_enabled());
-        with_allocator(allocator(), [this, &e] {
-            e.upgrade_schema(region(), _schema, cleaner());
-        });
+        e.upgrade_schema(region(), _schema, cleaner());
     }
 }
 
diff --git a/row_cache.cc b/row_cache.cc
index fc1a37c443..9d7ab56b9d 100644
--- a/row_cache.cc
+++ b/row_cache.cc
@@ -1324,9 +1324,7 @@ void row_cache::upgrade_entry(cache_entry& e) {
     if (e.schema() != _schema && !e.partition().is_locked()) {
         auto& r = _tracker.region();
         assert(!r.reclaiming_enabled());
-        with_allocator(r.allocator(), [this, &e] {
-            e.partition().upgrade(e.schema(), _schema, _tracker.cleaner(), &_tracker);
-        });
+        e.partition().upgrade(r, e.schema(), _schema, _tracker.cleaner(), &_tracker);
     }
 }
 
diff --git a/test/boost/mvcc_test.cc b/test/boost/mvcc_test.cc
index a6861c119f..343c8c88a5 100644
--- a/test/boost/mvcc_test.cc
+++ b/test/boost/mvcc_test.cc
@@ -170,7 +170,7 @@ public:
 
     void upgrade(schema_ptr new_schema) {
         _container.allocate_in_region([&] {
-            _e.upgrade(_s, new_schema, _container.cleaner(), _container.tracker());
+            _e.upgrade(_container.region(), _s, new_schema, _container.cleaner(), _container.tracker());
             _s = new_schema;
         });
     }
@@ -194,7 +194,7 @@ void mvcc_partition::apply_to_evictable(partition_entry&& src, schema_ptr src_sc
         mutation_cleaner src_cleaner(region(), no_cache_tracker, app_stats_for_tests);
         auto c = as(region(), [&] {
             if (_s != src_schema) {
-                src.upgrade(src_schema, _s, src_cleaner, no_cache_tracker);
+                src.upgrade(region(), src_schema, _s, src_cleaner, no_cache_tracker);
             }
             return _e.apply_to_incomplete(*schema(), std::move(src), src_cleaner, as, region(),
                 *_container.tracker(), _container.next_phase(), _container.accounter());