diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e9249e..04e9a05 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
 # Changes in Medidata.MAuth
-
+## v5.1.5
+- **[Core]** Fix bug in MAuth caching response
 ## v5.1.4
 - **[Core]** Change the fallback behavior of caching from 1 hour to 5 minutes in case when there is no valid caching
   instruction provided by the MAuth server
diff --git a/src/Medidata.MAuth.Core/CacheExtensions.cs b/src/Medidata.MAuth.Core/CacheExtensions.cs
deleted file mode 100644
index 23375a7..0000000
--- a/src/Medidata.MAuth.Core/CacheExtensions.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-using System;
-using Microsoft.Extensions.Caching.Memory;
-
-namespace Medidata.MAuth.Core
-{
-    /// <summary>
-    /// Caching-related extension methods.
-    /// </summary>
-    public static class CacheExtensions
-    {
-        /// <summary>
-        /// Get or create an item in the cache.  If the specified key does not exist, the factory method will be executed to
-        /// create a new item, and that item will be inserted into the cache with that key.  Locking is based on the cache
-        /// key, to prevent multiple concurrent factory methods from executing for a single key, but allow multiple concurrent
-        /// factory methods to execute for different keys.
-        /// </summary>
-        /// <param name="cache">The memory cache.</param>
-        /// <param name="key">The cache key.</param>
-        /// <param name="factory">The factory method to create a new item if the key does not exist in the cache.</param>
-        /// <typeparam name="TItem">The cached item type.</typeparam>
-        /// <returns>The item that was retrieved from the cache or created.</returns>
-        public static TItem GetOrCreateWithLock<TItem>(
-            this IMemoryCache cache,
-            object key,
-            Func<ICacheEntry, TItem> factory)
-        {
-            if (cache.TryGetValue(key, out TItem item))
-            {
-                return item;
-            }
-
-            var lockStr = string.Intern("mutex_" + key.GetHashCode());
-
-            lock (lockStr)
-            {
-                if (cache.TryGetValue(key, out item))
-                {
-                    return item;
-                }
-
-                ICacheEntry entry = cache.CreateEntry(key);
-                item = factory(entry);
-                entry.SetValue(item);
-                entry.Dispose();
-                return item;
-            }
-        }
-    }
-}
diff --git a/src/Medidata.MAuth.Core/AsyncLazy.cs b/src/Medidata.MAuth.Core/Caching/AsyncLazy.cs
similarity index 70%
rename from src/Medidata.MAuth.Core/AsyncLazy.cs
rename to src/Medidata.MAuth.Core/Caching/AsyncLazy.cs
index f9cf378..7bf481f 100644
--- a/src/Medidata.MAuth.Core/AsyncLazy.cs
+++ b/src/Medidata.MAuth.Core/Caching/AsyncLazy.cs
@@ -1,9 +1,11 @@
-using System;
+using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
-namespace Medidata.MAuth.Core
+namespace Medidata.MAuth.Core.Caching
 {
+    [ExcludeFromCodeCoverage]
     internal class AsyncLazy<T> : Lazy<Task<T>>
     {
         public AsyncLazy(Func<T> valueFactory)
@@ -17,8 +19,5 @@ public AsyncLazy(Func<Task<T>> taskFactory)
         }
 
         public TaskAwaiter<T> GetAwaiter() => Value.GetAwaiter();
-
-        public ConfiguredTaskAwaitable<T> ConfigureAwait(bool continueOnCapturedContext)
-            => Value.ConfigureAwait(continueOnCapturedContext);
     }
 }
diff --git a/src/Medidata.MAuth.Core/Caching/CacheResult.cs b/src/Medidata.MAuth.Core/Caching/CacheResult.cs
new file mode 100644
index 0000000..03f6ef6
--- /dev/null
+++ b/src/Medidata.MAuth.Core/Caching/CacheResult.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace Medidata.MAuth.Core.Caching
+{
+    /// <summary>
+    /// Dto to store cache fields
+    /// </summary>
+    /// <typeparam name="TItem">Cache result type.</typeparam>
+    public class CacheResult<TItem>
+    {
+        /// <summary>
+        /// Item to store in cache.
+        /// </summary>
+        public TItem Result { get; set; }
+
+        /// <summary>
+        /// Flag to determine if the result should be cache.
+        /// </summary>
+        public bool ShouldCache { get; set; }
+
+        /// <summary>
+        /// Cache duration.
+        /// </summary>
+        public TimeSpan AbsoluteCacheDuration { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Medidata.MAuth.Core/Caching/ICacheService.cs b/src/Medidata.MAuth.Core/Caching/ICacheService.cs
new file mode 100644
index 0000000..fe2efb5
--- /dev/null
+++ b/src/Medidata.MAuth.Core/Caching/ICacheService.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Medidata.MAuth.Core.Caching
+{
+    /// <summary>
+    /// Caching abstraction
+    /// </summary>
+    public interface ICacheService
+    {
+        /// <summary>
+        /// Gets or create cache item with locking.
+        /// </summary>
+        /// <typeparam name="TItem">The cached item type.</typeparam>
+        /// <param name="key">Cache Key</param>
+        /// <param name="factory">Factory method to create cached item</param>
+        /// <returns>The item that was retrieved from the cache or created.</returns>
+        Task<TItem> GetOrCreateWithLock<TItem>(
+            string key,
+            Func<Task<CacheResult<TItem>>> factory);
+
+        /// <summary>
+        /// Remove key from cache if exists.
+        /// </summary>
+        /// <param name="key"></param>
+        void Remove(string key);
+    }
+}
diff --git a/src/Medidata.MAuth.Core/Caching/MemoryCacheService.cs b/src/Medidata.MAuth.Core/Caching/MemoryCacheService.cs
new file mode 100644
index 0000000..c7b9e5e
--- /dev/null
+++ b/src/Medidata.MAuth.Core/Caching/MemoryCacheService.cs
@@ -0,0 +1,127 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace Medidata.MAuth.Core.Caching
+{
+    /// <summary>
+    /// In-Memory Cache service
+    /// </summary>
+    public class MemoryCacheService : ICacheService
+    {
+        private readonly IMemoryCache _cache;
+
+        /// <summary>
+        /// In Memory Cache Service
+        /// </summary>
+        /// <param name="cache"></param>
+        public MemoryCacheService(IMemoryCache cache)
+        {
+            _cache = cache;
+        }
+
+        /// <summary>
+        /// Checks if key is in the cache
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="value"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns>True when key found in cache.</returns>
+        public bool TryGetValue<T>(string key, out T value)
+            => _cache.TryGetValue(key, out value);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="key"></param>
+        public void Remove(string key) => _cache.Remove(key);
+
+        /// <summary>
+        /// Add an item to the cache.
+        /// </summary>
+        /// <param name="key">Cache Key</param>
+        /// <param name="value">Item to cache</param>
+        /// <param name="expiration">Cache Expiration</param>
+        public void SetItem<T>(string key, T value, DateTimeOffset expiration)
+            => _cache.Set(key, value, expiration);
+
+        /// <summary>
+        /// Gets or create cache item with locking.
+        /// </summary>
+        /// <typeparam name="TItem">The cached item type.</typeparam>
+        /// <param name="key">Cache Key</param>
+        /// <param name="factory">Factory method to create cached item</param>
+        /// <returns>Cached Item</returns>
+        public async Task<TItem> GetOrCreateWithLock<TItem>(
+            string key,
+            Func<Task<CacheResult<TItem>>> factory)
+        {
+            if (TryGetValue(key, out TItem item))
+            {
+                return item;
+            }
+
+            return await CreateAsyncLazyWithLock(key, factory);
+        }
+        
+        [ExcludeFromCodeCoverage]
+        private AsyncLazy<TItem> CreateAsyncLazyWithLock<TItem>(string key, Func<Task<CacheResult<TItem>>> factory)
+        {
+            var asyncKey = CreateAsyncKey(key);
+            
+            if (TryGetValue(asyncKey, out AsyncLazy<TItem> asyncItem))
+            {
+                return asyncItem;
+            }
+            
+            var lockStr = string.Intern("mutex_" + asyncKey);
+
+            lock (lockStr)
+            {
+                if (TryGetValue(asyncKey, out asyncItem))
+                {
+                    return asyncItem;
+                }
+                
+                if (TryGetValue(key, out TItem item))
+                {
+                    return new AsyncLazy<TItem>(() => item);
+                }
+
+                asyncItem = new AsyncLazy<TItem>(() => CreateLazyFactory(key, factory));
+                
+                _cache.Set(asyncKey, asyncItem);
+            }
+
+            return asyncItem;
+        }
+        
+        private async Task<TItem> CreateLazyFactory<TItem>(string key,  Func<Task<CacheResult<TItem>>> factory)
+        {
+            try
+            {
+                var result = await factory().ConfigureAwait(false);
+            
+                if (!result.ShouldCache)
+                {
+                    return result.Result;
+                }
+                
+                using var entry = _cache.CreateEntry(key);
+                entry.AbsoluteExpiration =  DateTimeOffset.UtcNow + result.AbsoluteCacheDuration;
+                entry.SetValue(result.Result);
+                return result.Result;
+            }
+            finally
+            {
+                var asyncKey = CreateAsyncKey(key);
+                _cache.Remove(asyncKey);
+            }
+            
+        }
+        
+        private string CreateAsyncKey(string key) => $"{key}-async";
+        
+    }
+}
diff --git a/src/Medidata.MAuth.Core/Caching/NoopCacheService.cs b/src/Medidata.MAuth.Core/Caching/NoopCacheService.cs
new file mode 100644
index 0000000..77dd1df
--- /dev/null
+++ b/src/Medidata.MAuth.Core/Caching/NoopCacheService.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace Medidata.MAuth.Core.Caching
+{
+    /// <summary>
+    /// Noop Cache Service
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class NoopCacheService : ICacheService
+    {
+        /// <summary>
+        /// Gets or create cache item with locking.
+        /// </summary>
+        /// <typeparam name="TItem">The cached item type.</typeparam>
+        /// <param name="key">Cache Key</param>
+        /// <param name="factory">Factory method to create cached item</param>
+        /// <returns>Cached Item</returns>
+        public async Task<TItem> GetOrCreateWithLock<TItem>(
+            string key,
+            Func<Task<CacheResult<TItem>>> factory)
+        {
+            var data = await factory().ConfigureAwait(false);
+            return data.Result;
+        }
+
+        /// <summary>
+        /// Remove key from cache if exists.
+        /// </summary>
+        /// <param name="key"></param>
+        public void Remove(string key)
+        {
+        }
+    }
+}
diff --git a/src/Medidata.MAuth.Core/MAuthAuthenticator.cs b/src/Medidata.MAuth.Core/MAuthAuthenticator.cs
index cee6438..fc1bf39 100644
--- a/src/Medidata.MAuth.Core/MAuthAuthenticator.cs
+++ b/src/Medidata.MAuth.Core/MAuthAuthenticator.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Threading.Tasks;
+using Medidata.MAuth.Core.Caching;
 using Medidata.MAuth.Core.Exceptions;
 using Microsoft.Extensions.Caching.Memory;
 using Org.BouncyCastle.Crypto;
@@ -12,14 +13,14 @@ namespace Medidata.MAuth.Core
 {
     internal class MAuthAuthenticator
     {
-        private readonly IMemoryCache _cache;
+        private readonly ICacheService _cache;
         private readonly MAuthOptionsBase _options;
         private readonly ILogger _logger;
         private readonly Lazy<HttpClient> _lazyHttpClient;
 
         public Guid ApplicationUuid => _options.ApplicationUuid;
 
-        public MAuthAuthenticator(MAuthOptionsBase options, ILogger logger, IMemoryCache cache = null)
+        public MAuthAuthenticator(MAuthOptionsBase options, ILogger logger, ICacheService cacheService = null)
         {
             if (options.ApplicationUuid == default)
                 throw new ArgumentException(nameof(options.ApplicationUuid));
@@ -30,7 +31,7 @@ public MAuthAuthenticator(MAuthOptionsBase options, ILogger logger, IMemoryCache
             if (string.IsNullOrWhiteSpace(options.PrivateKey))
                 throw new ArgumentNullException(nameof(options.PrivateKey));
 
-            _cache = cache ?? new MemoryCache(new MemoryCacheOptions());
+            _cache = cacheService ?? new MemoryCacheService(new MemoryCache(new MemoryCacheOptions()));
             _options = options;
             _logger = logger;
             _lazyHttpClient = new Lazy<HttpClient>(() => CreateHttpClient(options));
@@ -103,29 +104,17 @@ private async Task<bool> Authenticate(HttpRequestMessage request, MAuthVersion v
 
             var mAuthCore = MAuthCoreFactory.Instantiate(version);
             var authInfo = GetAuthenticationInfo(request, mAuthCore);
+            
+            var appInfo = await _cache.GetOrCreateWithLock(
+                    authInfo.ApplicationUuid.ToString(),
+                    () => SendApplicationInfoRequest(authInfo.ApplicationUuid)).ConfigureAwait(false);
 
-            try
-            {
-                var appInfo = await GetApplicationInfo(authInfo.ApplicationUuid).ConfigureAwait(false);
+            var signature = await mAuthCore.GetSignature(request, authInfo).ConfigureAwait(false);
+            return mAuthCore.Verify(authInfo.Payload, signature, appInfo.PublicKey);
 
-                var signature = await mAuthCore.GetSignature(request, authInfo).ConfigureAwait(false);
-                return mAuthCore.Verify(authInfo.Payload, signature, appInfo.PublicKey);
-            }
-            catch (RetriedRequestException)
-            {
-                // If the appliation info could not be fetched, remove the lazy
-                // object from the cache to allow for another attempt.
-                _cache.Remove(authInfo.ApplicationUuid);
-                throw;
             }
-        }
-
-        private AsyncLazy<ApplicationInfo> GetApplicationInfo(Guid applicationUuid) =>
-            _cache.GetOrCreateWithLock(
-                applicationUuid,
-                entry => new AsyncLazy<ApplicationInfo>(() => SendApplicationInfoRequest(entry, applicationUuid)));
-
-        private async Task<ApplicationInfo> SendApplicationInfoRequest(ICacheEntry entry, Guid applicationUuid)
+        
+        private async Task<CacheResult<ApplicationInfo>> SendApplicationInfoRequest(Guid applicationUuid)
         {
             var logMessage = "Mauth-client requesting from mAuth service application info not available " +
                              $"in the local cache for app uuid {applicationUuid}.";
@@ -139,16 +128,19 @@ private async Task<ApplicationInfo> SendApplicationInfoRequest(ICacheEntry entry
             ).ConfigureAwait(false);
 
             var result = await response.Content.FromResponse().ConfigureAwait(false);
-
-            entry.SetOptions(
-                new MemoryCacheEntryOptions()
-                    .SetAbsoluteExpiration(response.Headers.CacheControl?.MaxAge ?? TimeSpan.FromMinutes(5))
-            );
-
+            
             logMessage = $"Mauth-client application info for app uuid {applicationUuid} cached in memory.";
             _logger.LogInformation(logMessage);
 
-            return result;
+            var cacheResult = new CacheResult<ApplicationInfo>
+            {
+                ShouldCache = true,
+                Result = result,
+                AbsoluteCacheDuration = response.Headers.CacheControl?.MaxAge ?? TimeSpan.FromMinutes(5),
+            };
+            
+            return cacheResult;
+                
         }
 
         /// <summary>
diff --git a/src/Medidata.MAuth.Core/UtilityExtensions.cs b/src/Medidata.MAuth.Core/UtilityExtensions.cs
index 8a6c8b8..5b61ba9 100644
--- a/src/Medidata.MAuth.Core/UtilityExtensions.cs
+++ b/src/Medidata.MAuth.Core/UtilityExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net.Http;
 using System.Threading.Tasks;
+using Medidata.MAuth.Core.Caching;
 using Medidata.MAuth.Core.Models;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
@@ -13,7 +14,8 @@ namespace Medidata.MAuth.Core
     /// </summary>
     public static class UtilityExtensions
     {
-        private static readonly IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
+        private static readonly ICacheService _cache 
+            = new MemoryCacheService(new MemoryCache(new MemoryCacheOptions()));
 
         /// <summary>
         /// Parses an MAuth authentication HTTP header value for the application uuid and the MAuth signature payload.
diff --git a/version.props b/version.props
index 17b6840..89f0dbf 100644
--- a/version.props
+++ b/version.props
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version>5.1.4</Version>
+    <Version>5.1.5</Version>
   </PropertyGroup>
 </Project>