diff --git a/src/Polly.Core/Hedging/Controller/HedgingHandler.cs b/src/Polly.Core/Hedging/Controller/HedgingHandler.cs
index 4b61b14b909..e5839ae6d95 100644
--- a/src/Polly.Core/Hedging/Controller/HedgingHandler.cs
+++ b/src/Polly.Core/Hedging/Controller/HedgingHandler.cs
@@ -2,7 +2,8 @@ namespace Polly.Hedging.Utils;
 
 internal sealed record class HedgingHandler<T>(
     Func<HedgingPredicateArguments<T>, ValueTask<bool>> ShouldHandle,
-    Func<HedgingActionGeneratorArguments<T>, Func<ValueTask<Outcome<T>>>?> ActionGenerator)
+    Func<HedgingActionGeneratorArguments<T>, Func<ValueTask<Outcome<T>>>?> ActionGenerator,
+    Func<OnHedgingArguments<T>, ValueTask>? OnHedging)
 {
     public Func<ValueTask<Outcome<T>>>? GenerateAction(HedgingActionGeneratorArguments<T> args)
     {
diff --git a/src/Polly.Core/Hedging/Controller/TaskExecution.cs b/src/Polly.Core/Hedging/Controller/TaskExecution.cs
index 568173ea299..c3f8d129f2e 100644
--- a/src/Polly.Core/Hedging/Controller/TaskExecution.cs
+++ b/src/Polly.Core/Hedging/Controller/TaskExecution.cs
@@ -127,6 +127,8 @@ public async ValueTask<bool> InitializeAsync<TState>(
                 return true;
             }
 
+            await HandleOnHedgingAsync(snapshot.Context, attemptNumber - 1).ConfigureAwait(Context.ContinueOnCapturedContext);
+
             ExecutionTaskSafe = ExecuteSecondaryActionAsync(action);
         }
         else
@@ -137,6 +139,21 @@ public async ValueTask<bool> InitializeAsync<TState>(
         return true;
     }
 
+    private async Task HandleOnHedgingAsync(ResilienceContext primaryContext, int attemptNumber)
+    {
+        var args = new OnHedgingArguments<T>(
+            primaryContext,
+            Context,
+            attemptNumber);
+
+        _telemetry.Report(new(ResilienceEventSeverity.Warning, HedgingConstants.OnHedgingEventName), Context, args);
+
+        if (_handler.OnHedging is { } onHedging)
+        {
+            await onHedging(args).ConfigureAwait(Context.ContinueOnCapturedContext);
+        }
+    }
+
     private HedgingActionGeneratorArguments<TResult> CreateArguments<TResult, TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> primaryCallback,
         ResilienceContext primaryContext,
diff --git a/src/Polly.Core/Hedging/HedgingActionGeneratorArguments.cs b/src/Polly.Core/Hedging/HedgingActionGeneratorArguments.cs
index 8fe5ff18b80..46bf1193696 100644
--- a/src/Polly.Core/Hedging/HedgingActionGeneratorArguments.cs
+++ b/src/Polly.Core/Hedging/HedgingActionGeneratorArguments.cs
@@ -7,19 +7,22 @@ namespace Polly.Hedging;
 /// </summary>
 /// <typeparam name="TResult">The type of the result.</typeparam>
 /// <remarks>
+/// The <see cref="PrimaryContext"/> represents the context that was received by the hedging strategy and used to execute the primary action.
+/// To prevent race conditions, the hedging strategy then clones the primary context into <see cref="ActionContext"/> and uses it to execute the hedged action.
+/// Every hedged action gets its own context that is cloned from the primary.
+/// <para>
 /// Always use the constructor when creating this struct, otherwise we do not guarantee binary compatibility.
+/// </para>
 /// </remarks>
 public readonly struct HedgingActionGeneratorArguments<TResult>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="HedgingActionGeneratorArguments{TResult}"/> struct.
     /// </summary>
-    /// <param name="primaryContext">The primary resilience context.</param>
-    /// <param name="actionContext">
-    /// The context that will be passed to action generated by <see cref="HedgingStrategyOptions{TResult}.ActionGenerator"/>.
-    /// .</param>
+    /// <param name="primaryContext">The primary context received by the hedging strategy.</param>
+    /// <param name="actionContext">The action context. cloned from the primary context.</param>
     /// <param name="attemptNumber">The zero-based hedging attempt number.</param>
-    /// <param name="callback">The callback passed to hedging strategy.</param>
+    /// <param name="callback">The callback passed to the hedging strategy.</param>
     public HedgingActionGeneratorArguments(
         ResilienceContext primaryContext,
         ResilienceContext actionContext,
@@ -33,12 +36,12 @@ public HedgingActionGeneratorArguments(
     }
 
     /// <summary>
-    /// Gets the primary resilience context.
+    /// Gets the primary resilience context as received by the hedging strategy.
     /// </summary>
     public ResilienceContext PrimaryContext { get; }
 
     /// <summary>
-    /// Gets the context that will be passed to action generated by <see cref="HedgingStrategyOptions{TResult}.ActionGenerator"/>.
+    /// Gets the action context that will be used for the hedged action.
     /// </summary>
     /// <remarks>
     /// This context is cloned from <see cref="PrimaryContext"/>.
@@ -51,7 +54,7 @@ public HedgingActionGeneratorArguments(
     public int AttemptNumber { get; }
 
     /// <summary>
-    /// Gets the callback passed to hedging strategy.
+    /// Gets the callback passed to the hedging strategy.
     /// </summary>
     public Func<ResilienceContext, ValueTask<Outcome<TResult>>> Callback { get; }
 }
diff --git a/src/Polly.Core/Hedging/HedgingResiliencePipelineBuilderExtensions.cs b/src/Polly.Core/Hedging/HedgingResiliencePipelineBuilderExtensions.cs
index 1c46dd4463a..ef4e327b0b5 100644
--- a/src/Polly.Core/Hedging/HedgingResiliencePipelineBuilderExtensions.cs
+++ b/src/Polly.Core/Hedging/HedgingResiliencePipelineBuilderExtensions.cs
@@ -35,13 +35,12 @@ public static class HedgingResiliencePipelineBuilderExtensions
 
     private static HedgingResilienceStrategy<TResult> CreateHedgingStrategy<TResult>(StrategyBuilderContext context, HedgingStrategyOptions<TResult> options)
     {
-        var handler = new HedgingHandler<TResult>(options.ShouldHandle!, options.ActionGenerator);
+        var handler = new HedgingHandler<TResult>(options.ShouldHandle!, options.ActionGenerator, options.OnHedging);
 
         return new HedgingResilienceStrategy<TResult>(
             options.Delay,
             options.MaxHedgedAttempts,
             handler,
-            options.OnHedging,
             options.DelayGenerator,
             context.TimeProvider,
             context.Telemetry);
diff --git a/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs b/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs
index b8c8cf1ea25..097bb6ef578 100644
--- a/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs
+++ b/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs
@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using Polly.Hedging.Controller;
 using Polly.Hedging.Utils;
 using Polly.Telemetry;
 
@@ -6,15 +7,12 @@ namespace Polly.Hedging;
 
 internal sealed class HedgingResilienceStrategy<T> : ResilienceStrategy<T>
 {
-    private readonly TimeProvider _timeProvider;
-    private readonly ResilienceStrategyTelemetry _telemetry;
     private readonly HedgingController<T> _controller;
 
     public HedgingResilienceStrategy(
         TimeSpan hedgingDelay,
         int maxHedgedAttempts,
         HedgingHandler<T> hedgingHandler,
-        Func<OnHedgingArguments<T>, ValueTask>? onHedging,
         Func<HedgingDelayGeneratorArguments, ValueTask<TimeSpan>>? hedgingDelayGenerator,
         TimeProvider timeProvider,
         ResilienceStrategyTelemetry telemetry)
@@ -22,11 +20,7 @@ public HedgingResilienceStrategy(
         HedgingDelay = hedgingDelay;
         TotalAttempts = maxHedgedAttempts + 1; // include the initial attempt
         DelayGenerator = hedgingDelayGenerator;
-        _timeProvider = timeProvider;
         HedgingHandler = hedgingHandler;
-        OnHedging = onHedging;
-
-        _telemetry = telemetry;
         _controller = new HedgingController<T>(telemetry, timeProvider, HedgingHandler, TotalAttempts);
     }
 
@@ -38,8 +32,6 @@ public HedgingResilienceStrategy(
 
     public HedgingHandler<T> HedgingHandler { get; }
 
-    public Func<OnHedgingArguments<T>, ValueTask>? OnHedging { get; }
-
     [ExcludeFromCodeCoverage] // coverlet issue
     protected internal override async ValueTask<Outcome<T>> ExecuteCore<TState>(
         Func<ResilienceContext, TState, ValueTask<Outcome<T>>> callback,
@@ -71,11 +63,8 @@ private async ValueTask<Outcome<T>> ExecuteCoreAsync<TState>(
         var cancellationToken = context.CancellationToken;
         var continueOnCapturedContext = context.ContinueOnCapturedContext;
 
-        var attempt = -1;
         while (true)
         {
-            attempt++;
-            var start = _timeProvider.GetTimestamp();
             if (cancellationToken.IsCancellationRequested)
             {
                 return Outcome.FromException<T>(new OperationCanceledException(cancellationToken).TrySetStackTrace());
@@ -92,10 +81,6 @@ private async ValueTask<Outcome<T>> ExecuteCoreAsync<TState>(
             var execution = await hedgingContext.TryWaitForCompletedExecutionAsync(delay).ConfigureAwait(continueOnCapturedContext);
             if (execution is null)
             {
-                // If completedHedgedTask is null it indicates that we still do not have any finished hedged task within the hedging delay.
-                // We will create additional hedged task in the next iteration.
-                await HandleOnHedgingAsync(
-                    new OnHedgingArguments<T>(context, null, attempt, duration: delay)).ConfigureAwait(context.ContinueOnCapturedContext);
                 continue;
             }
 
@@ -106,23 +91,6 @@ await HandleOnHedgingAsync(
                 execution.AcceptOutcome();
                 return outcome;
             }
-
-            var executionTime = _timeProvider.GetElapsedTime(start);
-            await HandleOnHedgingAsync(
-                new OnHedgingArguments<T>(context, outcome, attempt, executionTime)).ConfigureAwait(context.ContinueOnCapturedContext);
-        }
-    }
-
-    private async ValueTask HandleOnHedgingAsync(OnHedgingArguments<T> args)
-    {
-        _telemetry.Report<OnHedgingArguments<T>, T>(new(ResilienceEventSeverity.Warning, HedgingConstants.OnHedgingEventName), args.Context, default, args);
-
-        if (OnHedging is not null)
-        {
-            // If nothing has been returned or thrown yet, the result is a transient failure,
-            // and other hedged request will be awaited.
-            // Before it, one needs to perform the task adjacent to each hedged call.
-            await OnHedging(args).ConfigureAwait(args.Context.ContinueOnCapturedContext);
         }
     }
 
diff --git a/src/Polly.Core/Hedging/OnHedgingArguments.cs b/src/Polly.Core/Hedging/OnHedgingArguments.cs
index 3ac88c1867a..b5fffb13adc 100644
--- a/src/Polly.Core/Hedging/OnHedgingArguments.cs
+++ b/src/Polly.Core/Hedging/OnHedgingArguments.cs
@@ -7,43 +7,43 @@ namespace Polly.Hedging;
 /// </summary>
 /// <typeparam name="TResult">The type of result.</typeparam>
 /// <remarks>
+/// The <see cref="PrimaryContext"/> represents the context that was received by the hedging strategy and used to execute the primary action.
+/// To prevent race conditions, the hedging strategy then clones the primary context into <see cref="ActionContext"/> and uses it to execute the hedged action.
+/// Every hedged action gets its own context that is cloned from the primary.
+/// <para>
 /// Always use the constructor when creating this struct, otherwise we do not guarantee binary compatibility.
+/// </para>
 /// </remarks>
 public readonly struct OnHedgingArguments<TResult>
 {
     /// <summary>
     /// Initializes a new instance of the <see cref="OnHedgingArguments{TResult}"/> struct.
     /// </summary>
-    /// <param name="outcome">The context in which the resilience operation or event occurred.</param>
-    /// <param name="context">The outcome of the resilience operation or event.</param>
+    /// <param name="primaryContext">The primary context received by the hedging strategy.</param>
+    /// <param name="actionContext">The action context. cloned from the primary context.</param>
     /// <param name="attemptNumber">The zero-based hedging attempt number.</param>
-    /// <param name="duration">The execution duration of hedging attempt or the hedging delay in case the attempt was not finished in time.</param>
-    public OnHedgingArguments(ResilienceContext context, Outcome<TResult>? outcome, int attemptNumber, TimeSpan duration)
+    public OnHedgingArguments(ResilienceContext primaryContext, ResilienceContext actionContext, int attemptNumber)
     {
-        Context = context;
-        Outcome = outcome;
+        PrimaryContext = primaryContext;
+        ActionContext = actionContext;
         AttemptNumber = attemptNumber;
-        Duration = duration;
     }
 
     /// <summary>
-    /// Gets the outcome that needs to be hedged, if any.
+    /// Gets the primary resilience context as received by the hedging strategy.
     /// </summary>
-    /// <remarks>If this property is <see langword="null"/>, it's an indication that user-callback or hedged operation did not complete within the hedging delay.</remarks>
-    public Outcome<TResult>? Outcome { get; }
+    public ResilienceContext PrimaryContext { get; }
 
     /// <summary>
-    /// Gets the context of this event.
+    /// Gets the action context that will be used for the hedged action.
     /// </summary>
-    public ResilienceContext Context { get; }
+    /// <remarks>
+    /// This context is cloned from <see cref="PrimaryContext"/>.
+    /// </remarks>
+    public ResilienceContext ActionContext { get; }
 
     /// <summary>
     /// Gets the zero-based hedging attempt number.
     /// </summary>
     public int AttemptNumber { get; }
-
-    /// <summary>
-    /// Gets the execution duration of hedging attempt or the hedging delay in case the attempt was not finished in time.
-    /// </summary>
-    public TimeSpan Duration { get; }
 }
diff --git a/src/Polly.Core/PublicAPI.Unshipped.txt b/src/Polly.Core/PublicAPI.Unshipped.txt
index 96906d8113d..8ea9b8c5d6c 100644
--- a/src/Polly.Core/PublicAPI.Unshipped.txt
+++ b/src/Polly.Core/PublicAPI.Unshipped.txt
@@ -143,12 +143,11 @@ Polly.Hedging.HedgingStrategyOptions<TResult>.OnHedging.set -> void
 Polly.Hedging.HedgingStrategyOptions<TResult>.ShouldHandle.get -> System.Func<Polly.Hedging.HedgingPredicateArguments<TResult>, System.Threading.Tasks.ValueTask<bool>>!
 Polly.Hedging.HedgingStrategyOptions<TResult>.ShouldHandle.set -> void
 Polly.Hedging.OnHedgingArguments<TResult>
+Polly.Hedging.OnHedgingArguments<TResult>.ActionContext.get -> Polly.ResilienceContext!
 Polly.Hedging.OnHedgingArguments<TResult>.AttemptNumber.get -> int
-Polly.Hedging.OnHedgingArguments<TResult>.Context.get -> Polly.ResilienceContext!
-Polly.Hedging.OnHedgingArguments<TResult>.Duration.get -> System.TimeSpan
 Polly.Hedging.OnHedgingArguments<TResult>.OnHedgingArguments() -> void
-Polly.Hedging.OnHedgingArguments<TResult>.OnHedgingArguments(Polly.ResilienceContext! context, Polly.Outcome<TResult>? outcome, int attemptNumber, System.TimeSpan duration) -> void
-Polly.Hedging.OnHedgingArguments<TResult>.Outcome.get -> Polly.Outcome<TResult>?
+Polly.Hedging.OnHedgingArguments<TResult>.OnHedgingArguments(Polly.ResilienceContext! primaryContext, Polly.ResilienceContext! actionContext, int attemptNumber) -> void
+Polly.Hedging.OnHedgingArguments<TResult>.PrimaryContext.get -> Polly.ResilienceContext!
 Polly.HedgingResiliencePipelineBuilderExtensions
 Polly.LegacySupport
 Polly.Outcome
diff --git a/test/Polly.Core.Tests/Hedging/HedgingHandlerTests.cs b/test/Polly.Core.Tests/Hedging/HedgingHandlerTests.cs
index 2f988c279b1..5955c8058db 100644
--- a/test/Polly.Core.Tests/Hedging/HedgingHandlerTests.cs
+++ b/test/Polly.Core.Tests/Hedging/HedgingHandlerTests.cs
@@ -10,7 +10,10 @@ public async Task GenerateAction_Generic_Ok()
     {
         var handler = new HedgingHandler<string>(
             args => PredicateResult.True(),
-            args => () => Outcome.FromResultAsValueTask("ok"));
+            args => () => Outcome.FromResultAsValueTask("ok"),
+            args => default);
+
+        handler.OnHedging.Should().NotBeNull();
 
         var action = handler.GenerateAction(new HedgingActionGeneratorArguments<string>(
             ResilienceContextPool.Shared.Get(),
diff --git a/test/Polly.Core.Tests/Hedging/HedgingHelper.cs b/test/Polly.Core.Tests/Hedging/HedgingHelper.cs
index 995977544b5..d985d837972 100644
--- a/test/Polly.Core.Tests/Hedging/HedgingHelper.cs
+++ b/test/Polly.Core.Tests/Hedging/HedgingHelper.cs
@@ -7,9 +7,10 @@ internal static class HedgingHelper
 {
     public static HedgingHandler<T> CreateHandler<T>(
         Func<Outcome<T>, bool> shouldHandle,
-        Func<HedgingActionGeneratorArguments<T>, Func<ValueTask<Outcome<T>>>?> generator)
+        Func<HedgingActionGeneratorArguments<T>, Func<ValueTask<Outcome<T>>>?> generator,
+        Func<OnHedgingArguments<T>, ValueTask>? onHedging = null)
     {
-        return new HedgingHandler<T>(args => new ValueTask<bool>(shouldHandle(args.Outcome!))!, generator);
+        return new HedgingHandler<T>(args => new ValueTask<bool>(shouldHandle(args.Outcome!))!, generator, onHedging);
     }
 }
 
diff --git a/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs b/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
index 13e877146f2..c446eabf917 100644
--- a/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
+++ b/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
@@ -1,5 +1,4 @@
 using System.ComponentModel.DataAnnotations;
-using System.Globalization;
 using Polly.Hedging;
 using Polly.Testing;
 
@@ -35,8 +34,7 @@ public void AddHedgingT_InvalidOptions_Throws()
     [Fact]
     public async Task AddHedging_IntegrationTest()
     {
-        var hedgingWithoutOutcome = false;
-        ConcurrentQueue<string> results = new();
+        int hedgingCount = 0;
 
         var strategy = _builder
             .AddHedging(new()
@@ -64,15 +62,7 @@ public async Task AddHedging_IntegrationTest()
                 },
                 OnHedging = args =>
                 {
-                    if (args.Outcome is { } outcome)
-                    {
-                        results.Enqueue(outcome.Result!.ToString(CultureInfo.InvariantCulture)!);
-                    }
-                    else
-                    {
-                        hedgingWithoutOutcome = true;
-                    }
-
+                    hedgingCount++;
                     return default;
                 }
             })
@@ -85,8 +75,6 @@ public async Task AddHedging_IntegrationTest()
         });
 
         result.Should().Be("success");
-        results.Should().HaveCountGreaterThan(0);
-        results.Distinct().Should().ContainSingle("error");
-        hedgingWithoutOutcome.Should().BeTrue();
+        hedgingCount.Should().Be(4);
     }
 }
diff --git a/test/Polly.Core.Tests/Hedging/HedgingResilienceStrategyTests.cs b/test/Polly.Core.Tests/Hedging/HedgingResilienceStrategyTests.cs
index 82e757c0738..a26247366b7 100644
--- a/test/Polly.Core.Tests/Hedging/HedgingResilienceStrategyTests.cs
+++ b/test/Polly.Core.Tests/Hedging/HedgingResilienceStrategyTests.cs
@@ -21,7 +21,6 @@ public class HedgingResilienceStrategyTests : IDisposable
     private readonly HedgingTimeProvider _timeProvider;
     private readonly HedgingActions _actions;
     private readonly PrimaryStringTasks _primaryTasks;
-    private readonly List<object?> _results = new();
     private readonly CancellationTokenSource _cts = new();
     private readonly ITestOutputHelper _testOutput;
     private HedgingHandler<string>? _handler;
@@ -170,21 +169,20 @@ public async Task ExecuteAsync_EnsurePrimaryContextFlows()
         _options.MaxHedgedAttempts = 3;
         _options.OnHedging = args =>
         {
-            args.Context.Should().Be(primaryContext);
-
-            if (args.AttemptNumber == 0)
-            {
-                args.Context.Properties.Set(key, "dummy");
-            }
-
+            args.ActionContext.Should().NotBe(args.PrimaryContext);
+            args.PrimaryContext.Should().Be(primaryContext);
+            args.PrimaryContext.Properties.GetValue(key, string.Empty).Should().Be("dummy");
             attempts++;
-
             return default;
         };
 
         ConfigureHedging(args =>
         {
-            args.PrimaryContext.Properties.GetValue(key, string.Empty).Should().Be("dummy");
+            if (args.AttemptNumber == 1)
+            {
+                args.PrimaryContext.Properties.Set(key, "dummy");
+            }
+
             args.PrimaryContext.Should().Be(primaryContext);
             return () => Outcome.FromResultAsValueTask(Failure);
         });
@@ -192,7 +190,7 @@ public async Task ExecuteAsync_EnsurePrimaryContextFlows()
         var strategy = Create();
         var result = await strategy.ExecuteAsync(_ => new ValueTask<string>(Failure), primaryContext);
 
-        attempts.Should().Be(4);
+        attempts.Should().Be(3);
         primaryContext.Properties.GetValue(key, string.Empty).Should().Be("dummy");
     }
 
@@ -286,35 +284,6 @@ await TestUtilities.AssertWithTimeoutAsync(() =>
         await task;
     }
 
-    [Fact]
-    public async Task ExecuteAsync_EnsureSecondaryHedgedTaskReportedWithNoOutcome()
-    {
-        // arrange
-        using var cancelled = new ManualResetEvent(false);
-        var hasOutcome = true;
-        _options.OnHedging = args =>
-        {
-            hasOutcome = args.Outcome is not null;
-            return default;
-        };
-
-        ConfigureHedging(context => Outcome.FromResultAsValueTask(Success));
-
-        var strategy = Create();
-
-        // act
-        var task = strategy.ExecuteAsync(async token =>
-        {
-            await _timeProvider.Delay(TimeSpan.FromHours(24), token);
-            return Success;
-        });
-
-        // assert
-        _timeProvider.Advance(TimeSpan.FromHours(2));
-        hasOutcome.Should().BeFalse();
-        await task;
-    }
-
     [Fact]
     public async Task ExecuteAsync_EnsureDiscardedResultDisposed()
     {
@@ -330,7 +299,7 @@ public async Task ExecuteAsync_EnsureDiscardedResultDisposed()
             };
         });
 
-        var pipeline = Create(handler, null).AsPipeline();
+        var pipeline = Create(handler).AsPipeline();
 
         // act
         var resultTask = pipeline.ExecuteAsync(async token =>
@@ -549,8 +518,8 @@ public async Task ExecuteAsync_Secondary_CustomPropertiesAvailable()
     public async Task ExecuteAsync_OnHedgingEventThrows_EnsureExceptionRethrown()
     {
         // arrange
-        ConfigureHedging(args => () => Outcome.FromResultAsValueTask(Success));
         _options.OnHedging = _ => throw new InvalidOperationException("my-exception");
+        ConfigureHedging(args => () => Outcome.FromResultAsValueTask(Success));
         var strategy = Create();
 
         // act
@@ -883,21 +852,33 @@ public async Task ExecuteAsync_EnsureExceptionStackTracePreserved()
     [Fact]
     public async Task ExecuteAsync_EnsureOnHedgingCalled()
     {
+        var primaryContext = ResilienceContextPool.Shared.Get();
+        var key = new ResiliencePropertyKey<string>("my-key");
+        primaryContext.Properties.Set(key, "my-value");
+
         var attempts = new List<int>();
         _options.OnHedging = args =>
         {
-            args.Outcome.Should().NotBeNull();
-            args.Outcome!.Value.Result.Should().Be(Failure);
+            args.PrimaryContext.Should().Be(primaryContext);
+            args.ActionContext.Should().NotBe(args.PrimaryContext);
+            args.PrimaryContext.Properties.GetValue(key, string.Empty).Should().Be("my-value");
+            args.ActionContext.Properties.GetValue(key, string.Empty).Should().Be("my-value");
+            args.ActionContext.Properties.Set(key, "new-value");
             attempts.Add(args.AttemptNumber);
             return default;
         };
 
-        ConfigureHedging(res => res.Result == Failure, args => () => Outcome.FromResultAsValueTask(Failure));
+        ConfigureHedging(res => res.Result == Failure,
+            args => () =>
+            {
+                args.ActionContext.Properties.GetValue(key, string.Empty).Should().Be("new-value");
+                return Outcome.FromResultAsValueTask(Failure);
+            });
 
         var strategy = Create();
-        await strategy.ExecuteAsync(_ => new ValueTask<string>(Failure));
+        await strategy.ExecuteAsync(_ => new ValueTask<string>(Failure), primaryContext);
 
-        attempts.Should().HaveCount(_options.MaxHedgedAttempts + 1);
+        attempts.Should().HaveCount(_options.MaxHedgedAttempts);
         attempts.Should().BeInAscendingOrder();
         attempts[0].Should().Be(0);
     }
@@ -912,25 +893,12 @@ public async Task ExecuteAsync_EnsureOnHedgingTelemetry()
         var strategy = Create();
         await strategy.ExecuteAsync((_, _) => new ValueTask<string>(Failure), context, "state");
 
-        _events.Should().HaveCount(_options.MaxHedgedAttempts + 5);
+        _events.Should().HaveCount(_options.MaxHedgedAttempts + 4);
         _events.Select(v => v.Event.EventName).Distinct().Should().HaveCount(2);
     }
 
     private void ConfigureHedging()
     {
-        _options.OnHedging = args =>
-        {
-            lock (_results)
-            {
-                if (args.Outcome.HasValue)
-                {
-                    _results.Add(args.Outcome.Value.Result!);
-                }
-            }
-
-            return default;
-        };
-
         ConfigureHedging(_ => false, _actions.Generator);
     }
 
@@ -948,7 +916,7 @@ private void ConfigureHedging(
         Func<Outcome<string>, bool> shouldHandle,
         Func<HedgingActionGeneratorArguments<string>, Func<ValueTask<Outcome<string>>>?> generator)
     {
-        _handler = HedgingHelper.CreateHandler(shouldHandle, generator);
+        _handler = HedgingHelper.CreateHandler(shouldHandle, generator, _options.OnHedging);
     }
 
     private void ConfigureHedging(TimeSpan delay) => ConfigureHedging(args => async () =>
@@ -957,15 +925,12 @@ private void ConfigureHedging(TimeSpan delay) => ConfigureHedging(args => async
         return Outcome.FromResult("secondary");
     });
 
-    private ResiliencePipeline<string> Create() => Create(_handler!, _options.OnHedging).AsPipeline();
+    private ResiliencePipeline<string> Create() => Create(_handler!).AsPipeline();
 
-    private HedgingResilienceStrategy<T> Create<T>(
-        HedgingHandler<T> handler,
-        Func<OnHedgingArguments<T>, ValueTask>? onHedging) => new(
+    private HedgingResilienceStrategy<T> Create<T>(HedgingHandler<T> handler) => new(
         _options.Delay,
         _options.MaxHedgedAttempts,
         handler,
-        onHedging,
         _options.DelayGenerator,
         _timeProvider,
         _telemetry);
diff --git a/test/Polly.Core.Tests/Hedging/OnHedgingArgumentsTests.cs b/test/Polly.Core.Tests/Hedging/OnHedgingArgumentsTests.cs
index 8429277c7ea..75e44c5967b 100644
--- a/test/Polly.Core.Tests/Hedging/OnHedgingArgumentsTests.cs
+++ b/test/Polly.Core.Tests/Hedging/OnHedgingArgumentsTests.cs
@@ -7,11 +7,10 @@ public class OnHedgingArgumentsTests
     [Fact]
     public void Ctor_Ok()
     {
-        var args = new OnHedgingArguments<int>(ResilienceContextPool.Shared.Get(), Outcome.FromResult(1), 1, TimeSpan.FromSeconds(1));
+        var args = new OnHedgingArguments<int>(ResilienceContextPool.Shared.Get(), ResilienceContextPool.Shared.Get(), 1);
 
-        args.Context.Should().NotBeNull();
-        args.Outcome!.Value.Result.Should().Be(1);
+        args.PrimaryContext.Should().NotBeNull();
+        args.ActionContext.Should().NotBeNull();
         args.AttemptNumber.Should().Be(1);
-        args.Duration.Should().Be(TimeSpan.FromSeconds(1));
     }
 }