.net core services behaving differently

See more:

C#

.NET-Core

I have two .net core 2.2 services, InitialisationHandler and WorkingTicketHandler, one holds initial information and the other is intended to hold a working ticket.
The InitialisationHandler always has its information ready when asked, but the WorkingTicketHandler always returns a null record.

I need to figure out how to have WorkingTicketHandler hold on to its data just like InitialisationHandler does.

using VTModels.Other;

namespace VT_Online22.Infrastructure.Services
{
    /// <summary>
    /// Interface for the WorkingTicket Service
    /// </summary>
    public interface IWorkingTicketHandler
    {
        WorkingTicket GetWorkingTicket();
        void SaveWorkingTicket(WorkingTicket  argWorkingTicket);
        void ClearWorkingTicket();
    }

    /// <summary>
    /// WorkingTicket service class definition
    /// </summary>
    public class WorkingTicketHandler : IWorkingTicketHandler
    {

        public WorkingTicketHandler()
        {
            this.WorkingTicket = new WorkingTicket();
        }

        public WorkingTicket GetWorkingTicket()
        {
            return this.WorkingTicket;
        }

        public void SaveWorkingTicket(WorkingTicket arg_WorkingTicket)
        {
            this.WorkingTicket = arg_WorkingTicket;
        }

        public void ClearWorkingTicket()
        {
            this.WorkingTicket = new WorkingTicket();
        }

        private WorkingTicket WorkingTicket;
        private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(typeof(WorkingTicketHandler));
    }
}

using Microsoft.Extensions.Configuration;
using SharedModels.Models;
using System.Collections.Generic;
using System.Threading.Tasks;
using VT_OnlineCore.Infrastructure.Other;
using VTModels.Models;

namespace VT_Online22.Infrastructure.Services
{
    /// <summary>
    /// Interface for the Initialization Service
    /// </summary>
    public interface IInitializationHandler
    {
        void Initialize();
        CConfigMasterBase GetConfig();
        IEnumerable<CScopeMasterBase> GetScopes(string clientId);
    }

    /// <summary>
    /// Initialization service class definition
    /// </summary>
    public class InitializationHandler : IInitializationHandler
    {

        public InitializationHandler(IConfiguration configTech)
        {
            ConfigurationTech = configTech;
            Initialize();
        }

        public void Initialize()
        {
            this.ldh = new LocalDataHandler(logger, this.ConfigurationTech);
            this.config = new CConfigMasterBase();
            LoadConfig();
        }

        public IEnumerable<CScopeMasterBase> GetScopes(string clientId)
        {
            IEnumerable<CScopeMasterBase> scopes = new List<CScopeMasterBase>();
            scopes =  this.ldh.GetScopes(clientId);
            return scopes;
        }
        public CConfigMasterBase GetConfig()
        {

            return this.config;
        }

        private async Task LoadConfig()
        {
            this.config =   this.ldh.GetConfig();           
        }

        private LocalDataHandler ldh;
        private CConfigMasterBase config;
        private IEnumerable<CScopeMasterBase> scopes;
        private static readonly log4net.ILog logger = log4net.LogManager.GetLogger(typeof(InitializationHandler));

        public IConfiguration ConfigurationTech { get; private set; }
    }
}

services.AddTransient<IInitializationHandler,InitializationHandler>();
services.AddTransient<IWorkingTicketHandler, WorkingTicketHandler>();

What I have tried:

Both are added to as transient in ConfigureServices, and created as identically as possible.

There is one key difference, the InitialisationHandler has its data created during startup by its constructor method and is only ever read from thereafter, whereas the WorkingTicketHandler is written to by a controller and re read in the same controller (Get vs Post).