InRequestScope acting like InTransientScope

Question

I have an ASP.NET Web Application (.NET Framework 4.8) in which I've set up NInject but any services I set up with InRequestScope are coming through as if transient scope (i.e. new instances are created for every entity that depends a dependency on it - within the same web request).

The NuGet packages I am using are as follows (latest):

1. Ninject v3.3.4
2. Ninject.Web.Common v.3.32 ("Bootstrapper for web projects")

App_Start\Ninject.Web.Common.cs is present and correct and is as follows:

[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(ScormWebService.App_Start.NinjectWebCommon), "Start")]
[assembly: WebActivatorEx.ApplicationShutdownMethod(typeof(ScormWebService.App_Start.NinjectWebCommon), "Stop")]

namespace ScormWebService.App_Start
{
    using Microsoft.Web.Infrastructure.DynamicModuleHelper;
    using Ninject;
    using Ninject.Web.Common;
    using Ninject.Web.Common.WebHost;
    using Services;
    using System;
    using System.Web;

    public static class NinjectWebCommon
    {
        private static readonly Bootstrapper bootstrapper = new Bootstrapper();
        public static IKernel Kernel { get; private set; }

        /// <summary>
        /// Starts the application
        /// </summary>
        public static void Start()
        {
            DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule));
            DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule));
            bootstrapper.Initialize(CreateKernel);
        }

        /// <summary>
        /// Stops the application.
        /// </summary>
        public static void Stop()
        {
            bootstrapper.ShutDown();
        }

        /// <summary>
        /// Creates the kernel that will manage your application.
        /// </summary>
        /// <returns>The created kernel.</returns>
        private static IKernel CreateKernel()
        {
            var kernel = new StandardKernel();
            try
            {
                RegisterServices(kernel);
                return kernel;
            }
            catch
            {
                kernel.Dispose();
                throw;
            }
        }

        /// <summary>
        /// Load your modules or register your services here!
        /// </summary>
        /// <param name="kernel">The kernel</param>
        private static void RegisterServices(IKernel kernel)
        {
            kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
            kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();
            kernel.Bind<IDumpConfigService>().To<DumpConfigService>().InSingletonScope();

            // These objects are created fresh for each request
            kernel.Bind<ILogService>().To<LogService>().InRequestScope();
            kernel.Bind<IDumpService>().To<DumpService>().InRequestScope();
            kernel.Bind<ISaveDataRequestReader>().To<SaveDataRequestReaderXml>().InRequestScope();
            kernel.Bind<ISaveDataResponseWriter>().To<SaveDataResponseWriterXml>().InRequestScope();
            kernel.Bind<IHttpContextAccessor>().To<HttpContextAccessor>().InRequestScope();

            Kernel = kernel;
        }
    }
}

The incoming request is actually an implementation of IHttpHandler (i.e. an ashx rather than aspx file). However, it is still a page request with a current request and an HttpContext.Current.

Here is how I am setting up the entities for the page request

public class SaveDataHandler : IHttpHandler, IRequiresSessionState
{
    /// <summary>
    /// A new handler is required for each and every incoming request
    /// </summary>
    public bool IsReusable => false;

    public SaveDataHandler()
    {
        var kernel = App_Start.NinjectWebCommon.Kernel;
        LogService = (ILogService)kernel.GetService(typeof(ILogService));
        Reader = (ISaveDataRequestReader)kernel.GetService(typeof(ISaveDataRequestReader));
        Writer = (ISaveDataResponseWriter)kernel.GetService(typeof(ISaveDataResponseWriter));
        DumpService = (IDumpService)kernel.GetService(typeof(IDumpService));
    }

}

So for example, three instances of ILogService are created per request during the SaveDataHandler constructor instead of one: SaveDataHandler itself requests it (see above) as does class DumpService : IDumpService and class SaveDataRequestReaderXml : ISaveDataRequestReader.

Can anyone provide insight as to why InRequestScope is acting like a transient scope? I suspect the cause is using a IHttpHandler (ashx) instead of Web Form (aspx) page but I can't see why that wouldn't work as HttpContext.Current is the same across the request and that is what NInject.Web.Common uses as a request scope identifier. I've created a WebForm.aspx page but the same issue occurs for this too so it's not specific to ashx/IHttpHandler requests:

namespace ScormWebService
{
    public partial class WebForm1 : Page
    {
        protected void Page_Init(object sender, EventArgs e)
        {
            var kernel = App_Start.NinjectWebCommon.Kernel;
            var LogService = (ILogService)kernel.GetService(typeof(ILogService));
            var Reader = (ISaveDataRequestReader)kernel.GetService(typeof(ISaveDataRequestReader));
            var Writer = (ISaveDataResponseWriter)kernel.GetService(typeof(ISaveDataResponseWriter));
            var DumpService = (IDumpService)kernel.GetService(typeof(IDumpService));
            // At this point, three instances of LogService have been created.
        }
    }
}

Edit: I've created a fresh minimal ASP.NET Web Forms project that reproduces the problem which you can download here but all the essential elements are already described in the code above.

Thanks.