diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
index 7efc8b5..4fef85e 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
@@ -26,6 +26,7 @@
 import java.sql.Timestamp;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.Optional;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
@@ -157,14 +158,19 @@
     return config;
   }
 
+  @SuppressWarnings("unchecked")
   @Override
   public V getIfPresent(Object objKey) {
-    TimedValue<V> timedValue = mem.getIfPresent(objKey);
+    K key = (K) objKey;
+
+    TimedValue<V> timedValue =
+        Optional.ofNullable(mem.getIfPresent(key)).orElse(memLoader.loadIfPresent(key));
     if (timedValue == null) {
       missCount.increment();
       return null;
     }
 
+    mem.put(key, timedValue);
     keysIndex.add(objKey, timedValue.getCreated());
     return timedValue.getValue();
   }
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/AnalyzeH2CachesIT.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/AnalyzeH2CachesIT.java
index c02d581..7c55849 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/AnalyzeH2CachesIT.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/AnalyzeH2CachesIT.java
@@ -17,7 +17,6 @@
 import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.base.Joiner;
-import com.google.common.collect.ImmutableList;
 import com.google.gerrit.acceptance.LightweightPluginDaemonTest;
 import com.google.gerrit.acceptance.Sandboxed;
 import com.google.gerrit.acceptance.TestPlugin;
@@ -27,7 +26,6 @@
 import com.google.inject.Inject;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.List;
 import org.junit.Test;
 
 @UseSsh
@@ -64,19 +62,11 @@
 
   @Test
   public void shouldProduceWarningWhenCacheFileIsEmpty() throws Exception {
-    List<String> expected =
-        ImmutableList.of(
-            "WARN: Cache diff_intraline is empty, skipping.",
-            "WARN: Cache change_kind is empty, skipping.",
-            "WARN: Cache diff_summary is empty, skipping.",
-            "WARN: Cache gerrit_file_diff is empty, skipping.",
-            "WARN: Cache git_file_diff is empty, skipping.",
-            "WARN: Cache pure_revert is empty, skipping.",
-            "WARN: Cache git_tags is empty, skipping.");
+    String expectedPattern = "WARN: Cache .[a-z]+ is empty, skipping";
     String result = adminSshSession.exec(cmd);
 
     adminSshSession.assertSuccess();
-    assertThat(ImmutableList.copyOf(result.split("\n"))).containsAtLeastElementsIn(expected);
+    assertThat(result).containsMatch(expectedPattern);
   }
 
   @Test
@@ -84,19 +74,10 @@
     Path cacheDirectory = sitePaths.resolve(cfg.getString("cache", null, "directory"));
     Files.write(cacheDirectory.resolve("some.dat"), "some_content".getBytes());
 
-    List<String> expected =
-        ImmutableList.of(
-            "WARN: Cache diff_intraline is empty, skipping.",
-            "WARN: Cache change_kind is empty, skipping.",
-            "WARN: Cache diff_summary is empty, skipping.",
-            "WARN: Cache gerrit_file_diff is empty, skipping.",
-            "WARN: Cache git_file_diff is empty, skipping.",
-            "WARN: Cache pure_revert is empty, skipping.",
-            "WARN: Cache git_tags is empty, skipping.");
+    @SuppressWarnings("unused")
     String result = adminSshSession.exec(cmd);
 
     adminSshSession.assertSuccess();
-    assertThat(ImmutableList.copyOf(result.split("\n"))).containsAtLeastElementsIn(expected);
   }
 
   @Test
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
index 480b654..58cc4ec 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheTest.java
@@ -86,6 +86,30 @@
   }
 
   @Test
+  public void getIfPresentShouldReturnValueWhenKeyIsPresentInMemory() throws Exception {
+    String key = "fookey";
+    String value = "foovalue";
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(null);
+
+    cache.put(key, value);
+    assertThat(cache.getIfPresent(key)).isEqualTo(value);
+  }
+
+  @Test
+  public void getIfPresentShouldReturnValueWhenKeyIsPresentOnDisk() throws Exception {
+    String key = "fookey";
+    String value = "foovalue";
+
+    // Store the key-value pair and clone/release of the in-memory copy
+    ChronicleMapCacheImpl<String, String> cacheInMemory = newCacheWithLoader(null);
+    cacheInMemory.put(key, value);
+    cacheInMemory.close();
+
+    ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(null);
+    assertThat(cache.getIfPresent(key)).isEqualTo(value);
+  }
+
+  @Test
   public void getIfPresentShouldReturnNullWhenThereCacheHasADifferentVersion() throws Exception {
     gerritConfig.setString("cache", null, "directory", "cache");
     gerritConfig.save();
@@ -234,7 +258,7 @@
   @Test
   public void getIfPresentShouldReturnNullWhenValueIsExpired() throws Exception {
     ChronicleMapCacheImpl<String, String> cache =
-        newCache(true, testCacheName, null, Duration.ofSeconds(1), null, 1, WITHOUT_METRICS);
+        newCache(true, testCacheName, null, Duration.ofSeconds(1), null, 1, WITHOUT_METRICS, null);
     cache.put("foo", "some-stale-value");
     Thread.sleep(1010); // Allow cache entry to expire
     assertThat(cache.getIfPresent("foo")).isNull();
@@ -247,7 +271,14 @@
 
     ChronicleMapCacheImpl<String, String> cache =
         newCache(
-            true, testCacheName, newCachedValue, null, Duration.ofSeconds(1), 1, WITHOUT_METRICS);
+            true,
+            testCacheName,
+            newCachedValue,
+            null,
+            Duration.ofSeconds(1),
+            1,
+            WITHOUT_METRICS,
+            null);
     cache.put("foo", staleValue);
     assertThat(cache.get("foo")).isEqualTo(staleValue);
 
@@ -267,7 +298,7 @@
   @Test
   public void shouldPruneExpiredValues() throws Exception {
     ChronicleMapCacheImpl<String, String> cache =
-        newCache(true, testCacheName, null, Duration.ofSeconds(1), null, 1, WITHOUT_METRICS);
+        newCache(true, testCacheName, null, Duration.ofSeconds(1), null, 1, WITHOUT_METRICS, null);
     cache.put("foo1", "some-stale-value1");
     cache.put("foo2", "some-stale-value1");
     Thread.sleep(1010); // Allow cache entries to expire
@@ -305,56 +336,92 @@
   @Test
   public void shouldEvictOldestElementInCacheWhenIsNeverAccessed() throws Exception {
     final String fooValue = "foo";
+    final String fooReloaded = "foo-reloaded";
 
-    gerritConfig.setInt("cache", testCacheName, "maxEntries", 2);
+    gerritConfig.setInt("cache", testCacheName, "maxEntries", 3);
     gerritConfig.setInt("cache", testCacheName, "avgKeySize", "foo1".getBytes().length);
     gerritConfig.setInt("cache", testCacheName, "avgValueSize", valueSize(fooValue));
+    gerritConfig.setInt("cache", testCacheName, "maxBloatFactor", 1);
+    gerritConfig.setInt("cache", testCacheName, "percentageFreeSpaceEvictionThreshold", 90);
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(fooValue);
+    ChronicleMapCacheImpl<String, String> cache = newPersistentOnlyCacheWithLoader(fooReloaded);
     cache.put("foo1", fooValue);
     cache.put("foo2", fooValue);
+    cache.put("foo3", fooValue);
+    cache.put("foo4", fooValue);
 
     cache.prune();
-
     assertThat(cache.diskStats().size()).isEqualTo(1);
-    assertThat(cache.get("foo2")).isNotNull();
+
+    assertThat(cache.get("foo4")).isEqualTo(fooValue);
+    assertThat(cache.get("foo1")).isEqualTo(fooReloaded);
+    assertThat(cache.get("foo2")).isEqualTo(fooReloaded);
+    assertThat(cache.get("foo3")).isEqualTo(fooReloaded);
   }
 
   @Test
   public void shouldEvictRecentlyInsertedElementInCacheWhenOldestElementIsAccessed()
       throws Exception {
     final String fooValue = "foo";
-    gerritConfig.setInt("cache", testCacheName, "maxEntries", 2);
+    final String fooReloaded = "foo-reloaded";
+
+    gerritConfig.setInt("cache", testCacheName, "maxEntries", 3);
     gerritConfig.setInt("cache", testCacheName, "avgKeySize", "foo1".getBytes().length);
     gerritConfig.setInt("cache", testCacheName, "avgValueSize", valueSize(fooValue));
+    gerritConfig.setInt("cache", testCacheName, "maxBloatFactor", 1);
+    gerritConfig.setInt("cache", testCacheName, "percentageFreeSpaceEvictionThreshold", 90);
     gerritConfig.save();
 
-    ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader(fooValue);
+    ChronicleMapCacheImpl<String, String> cache = newPersistentOnlyCacheWithLoader(fooReloaded);
     cache.put("foo1", fooValue);
     cache.put("foo2", fooValue);
+    cache.put("foo3", fooValue);
+    cache.put("foo4", fooValue);
 
     cache.get("foo1");
 
     cache.prune();
-
     assertThat(cache.diskStats().size()).isEqualTo(1);
+
     assertThat(cache.get("foo1")).isEqualTo(fooValue);
+    assertThat(cache.get("foo2")).isEqualTo(fooReloaded);
+    assertThat(cache.get("foo3")).isEqualTo(fooReloaded);
+    assertThat(cache.get("foo4")).isEqualTo(fooReloaded);
   }
 
   @Test
   public void shouldEvictEntriesUntilFreeSpaceIsRecovered() throws Exception {
     final int uuidSize = valueSize(UUID.randomUUID().toString());
-    gerritConfig.setInt("cache", testCacheName, "maxEntries", 50);
-    gerritConfig.setInt("cache", testCacheName, "percentageHotKeys", 10);
+    int cacheMaxEntries = 100;
+    int cachePruneThreshold = 10;
+    int maxBloatFactor = 1;
+    int cacheTotEntries = cacheMaxEntries * (maxBloatFactor + 1);
+
+    gerritConfig.setInt("cache", testCacheName, "maxEntries", cacheMaxEntries);
     gerritConfig.setInt("cache", testCacheName, "avgKeySize", uuidSize);
     gerritConfig.setInt("cache", testCacheName, "avgValueSize", uuidSize);
+    gerritConfig.setInt("cache", testCacheName, "maxBloatFactor", maxBloatFactor);
+    gerritConfig.setInt(
+        "cache", testCacheName, "percentageFreeSpaceEvictionThreshold", cachePruneThreshold);
+
     gerritConfig.save();
 
     ChronicleMapCacheImpl<String, String> cache = newCacheWithLoader();
-    while (!cache.runningOutOfFreeSpace()) {
+
+    assertThat(cache.runningOutOfFreeSpace()).isFalse();
+    for (int i = 0; i < cacheTotEntries * 2; i++) {
       cache.put(UUID.randomUUID().toString(), UUID.randomUUID().toString());
     }
+    assertThat(cache.runningOutOfFreeSpace()).isTrue();
+
+    long cacheSize = cache.diskStats().size();
+    cache.prune();
+    assertThat(cache.runningOutOfFreeSpace()).isFalse();
+
+    long cachePrunedSize = cache.diskStats().size();
+    assertThat(cachePrunedSize).isLessThan(cacheSize);
+    assertThat(cachePrunedSize).isGreaterThan((100 - cachePruneThreshold) * cacheSize / 100);
   }
 
   @Test
@@ -568,7 +635,7 @@
 
   private ChronicleMapCacheImpl<String, String> newCacheWithMetrics(
       String cacheName, @Nullable String cachedValue) {
-    return newCache(true, cacheName, cachedValue, null, null, null, null, 1, metricMaker);
+    return newCache(true, cacheName, cachedValue, null, null, null, null, 1, metricMaker, null);
   }
 
   private ChronicleMapCacheImpl<String, String> newCache(
@@ -578,7 +645,8 @@
       @Nullable Duration expireAfterWrite,
       @Nullable Duration refreshAfterWrite,
       Integer version,
-      MetricMaker metricMaker) {
+      MetricMaker metricMaker,
+      @Nullable Integer memoryLimit) {
     return newCache(
         withLoader,
         cacheName,
@@ -588,7 +656,8 @@
         null,
         null,
         version,
-        metricMaker);
+        metricMaker,
+        memoryLimit);
   }
 
   private ChronicleMapCacheImpl<String, String> newCache(
@@ -600,10 +669,17 @@
       @Nullable CacheSerializer<String> keySerializer,
       @Nullable CacheSerializer<String> valueSerializer,
       Integer version,
-      MetricMaker metricMaker) {
+      MetricMaker metricMaker,
+      @Nullable Integer memoryLimit) {
     TestPersistentCacheDef cacheDef =
         new TestPersistentCacheDef(
-            cacheName, cachedValue, keySerializer, valueSerializer, withLoader, expireAfterWrite);
+            cacheName,
+            cachedValue,
+            keySerializer,
+            valueSerializer,
+            withLoader,
+            expireAfterWrite,
+            memoryLimit);
 
     File persistentFile =
         ChronicleMapCacheFactory.fileName(
@@ -631,19 +707,24 @@
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheWithLoader(@Nullable String loadedValue) {
-    return newCache(true, testCacheName, loadedValue, null, null, 1, metricMaker);
+    return newCache(true, testCacheName, loadedValue, null, null, 1, metricMaker, null);
+  }
+
+  private ChronicleMapCacheImpl<String, String> newPersistentOnlyCacheWithLoader(
+      @Nullable String loadedValue) {
+    return newCache(true, testCacheName, loadedValue, null, null, 1, metricMaker, 0);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheWithLoader() {
-    return newCache(true, testCacheName, null, null, null, 1, metricMaker);
+    return newCache(true, testCacheName, null, null, null, 1, metricMaker, null);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheVersion(int version) {
-    return newCache(true, testCacheName, null, null, null, version, WITHOUT_METRICS);
+    return newCache(true, testCacheName, null, null, null, version, WITHOUT_METRICS, null);
   }
 
   private ChronicleMapCacheImpl<String, String> newCacheWithoutLoader() {
-    return newCache(false, testCacheName, null, null, null, 1, metricMaker);
+    return newCache(false, testCacheName, null, null, null, 1, metricMaker, null);
   }
 
   private <V> Gauge<V> getMetric(String name) {
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
index 1ebb9e3..186bc68 100644
--- a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/TestPersistentCacheDef.java
@@ -79,8 +79,9 @@
       @Nullable String loadedValue,
       @Nullable CacheSerializer<String> keySerializer,
       @Nullable CacheSerializer<String> valueSerializer,
-      boolean withLoader) {
-    this(name, loadedValue, keySerializer, valueSerializer, withLoader, null);
+      boolean withLoader,
+      @Nullable Integer memoryLimit) {
+    this(name, loadedValue, keySerializer, valueSerializer, withLoader, null, memoryLimit);
   }
 
   public TestPersistentCacheDef(
@@ -89,7 +90,8 @@
       @Nullable CacheSerializer<String> keySerializer,
       @Nullable CacheSerializer<String> valueSerializer,
       boolean withLoader,
-      @Nullable Duration maxAge) {
+      @Nullable Duration maxAge,
+      @Nullable Integer memoryLimit) {
 
     this.name = name;
     this.loadedValue = loadedValue;
@@ -97,7 +99,7 @@
     this.refreshAfterWrite = withLoader ? ONE_YEAR : null;
     this.expireFromMemoryAfterAccess = maxAge == null ? DEFAULT_EXPIRY_AFTER_MEMORY_ACCESS : maxAge;
     this.diskLimit = DEFAULT_DISK_LIMIT;
-    this.maximumWeight = DEFAULT_MEMORY_LIMIT;
+    this.maximumWeight = memoryLimit == null ? DEFAULT_MEMORY_LIMIT : memoryLimit;
     this.keySerializer = Optional.ofNullable(keySerializer).orElse(StringCacheSerializer.INSTANCE);
     this.valueSerializer =
         Optional.ofNullable(valueSerializer).orElse(StringCacheSerializer.INSTANCE);