The `Records` is a backup configuration that would be used if there is any issues on the configuration. 

What I think you need is the following workflow: 
 

 1. On server startup, read the `JSON` configuration, download the file, and store `JSON` values statically. 
 2. After server started up, if the `JSON` values have been changed, get the new values, compared them with the stored values, and execute the logic based on this comparison. 

So, to prepare that we need to add a child private class which would store the json config values. Next, add static instance of this new private class which would store the current settings and On the ConfigChanged just compare between the new file name and the current one. Then, just load the settings from local or server or return the default values. 

You need a separate method for loading the `Default` settings (which is the backup). So, at the end you'll have three methods for loading the configurations. 

here is the changes you need (I have optout the rest of the code only included the changes).

 public class RecordManager
 {
 private static JsonConfiguation _jsonConfig; 
 
 	private class JsonConfiguation
 	{
 		public string RemoteFileName { get; set; }
 		
 		public bool LoadDefault { get; set; }
 		
 		public bool Reload { get; set; }
 	}
 
 	
 	public RecordManager(IConfiguration configuration, string localPath)
 	{
 		if(configuration == null) { throw new ArgumentNullException(nameof(configuration)); }
 		
 		if(localPath?.Length == 0) { throw new ArgumentNullException(nameof(localPath)); }
 		
 		_localPath = localPath;
 		
 		_configuration = configuration;
 		
 		if(_jsonConfig == null)
 			_jsonConfig = GetConfigValues();
 
 		ChangeToken.OnChange(configuration.GetReloadToken, _ => ConfigChanged(), new object());
 	}	
 
 	private JsonConfiguation GetConfigValuesFromJson()
 	{
 		string configValue = _configuration["configKey"];
 		
 		if (string.IsNullOrWhiteSpace(configValue)) { throw new ArgumentNullException(nameof(configValue)); }
 
 		var dcc = JsonConvert.DeserializeObject<ConsulConfig>(configValue);
 		
 		return new JsonConfiguation
 		{
 			RemoteFileName = _remoteFileName, 
 			LoadDefault = bool.TryParse(dcc.loadDefaultFlag?.ToString(), out bool loadDefaultFlag) ? loadDefaultFlag : false, 
 			Reload = bool.TryParse(dcc.reloadConfig?.ToString(), out bool reloadConfig) ? reloadConfig : false
 		};
 	}
 
 	
 	private void ConfigChanged()
 	{
 		var configNew = GetConfigValuesFromJson();
 		
 		// fallback in case if something happened unexpectedly. 
 		if(_jsonConfig == null)
 		{
 			_jsonConfig = configNew;
 		}
 		
 		var isFileSame = _jsonConfig.RemoteFileName.Equals(configNew.RemoteFileName, StringComparer.InvariantCultureIgnoreCase);
 		
 		if(!configNew.LoadDefault && isFileSame)
 		{
 			// if both (the current downloaded and on the remote) are the same
 			// just load the local config 
 			_records = GetConfigFromLocalFiles();
 		}
 		else if(!configNew.LoadDefault && !isFileSame)
 		{
 			// they're different, you need to redownload the file before going to the next step.
 			 _records = GetConfigFromServer();
 			 _jsonConfig = configNew;
 		}
 		else 
 		{
 			//reload the default configuration
 			 _records = GetDefaultConfiguration();
 			 _jsonConfig = configNew;
 		}
 			
 		// if it requires to reload the configuration immediately
 		// if not, it'll now reload the configuration, and it would be stored in this instance.
 		if(configNew.Reload)
 		{
 			 Save(); 
 		}
 
 	}
 
 private IEnumerable<RecordHolder> GetDefaultConfiguration()
 {
 // get the default config files already present in default "Records" folder
 // and return RecordHolder list back.
 }	
 
 	private IEnumerable<RecordHolder> GetConfigFromServer()
 	{
 // get the config files from the server 
 // and return RecordHolder list back.		
 	}
 	
 	
 private IEnumerable<RecordHolder> GetConfigFromLocalFiles()
 {
 // get the config files from the secondary location 
 // and return RecordHolder list back.
 }	
 	
 private bool IsConfigFromServer()
 {
 return !_jsonConfig.LoadDefault && !string.IsNullOrWhiteSpace(_jsonConfig.RemoteFileName);
 }
 	
 }