diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
index f124db121..618e93fd7 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.cpp
@@ -38,6 +38,55 @@ EventDataControlCompositeImpl<AtomicIndirectorType>::EventDataControlCompositeIm
     CheckForValidDataControls();
 }
 
+template <template <class> class AtomicIndirectorType>
+score::cpp::optional<SlotIndexType> EventDataControlCompositeImpl<AtomicIndirectorType>::FindLatestReadableSlotIndex(
+    const EventDataControl& control) const noexcept
+{
+    EventSlotStatus::EventTimeStamp latest_time_stamp{1U};
+    score::cpp::optional<SlotIndexType> latest_slot_index{};
+
+    for (SlotIndexType slot_index = 0U;
+         // Suppress "AUTOSAR C++14 A4-7-1" rule finding. This rule states: "An integer expression shall not lead
+         // to loss.". As the maximum number of slots is std::uint16_t, so there is no case for a data loss here.
+         // coverity[autosar_cpp14_a4_7_1_violation]
+         slot_index < static_cast<SlotIndexType>(control.state_slots_.size());
+         ++slot_index)
+    {
+        SCORE_LANGUAGE_FUTURECPP_ASSERT_PRD(static_cast<std::size_t>(slot_index) < control.state_slots_.size());
+        const EventSlotStatus slot{control.state_slots_[slot_index].load(std::memory_order_acquire)};
+        if (!slot.IsInvalid() && !slot.IsInWriting())
+        {
+            const auto slot_time_stamp = slot.GetTimeStamp();
+            if (latest_time_stamp < slot_time_stamp)
+            {
+                latest_time_stamp = slot_time_stamp;
+                latest_slot_index = slot_index;
+            }
+        }
+    }
+
+    return latest_slot_index;
+}
+
+template <template <class> class AtomicIndirectorType>
+bool EventDataControlCompositeImpl<AtomicIndirectorType>::TryIncreaseReferenceCount(
+    ControlSlotType& slot) const noexcept
+{
+    EventSlotStatus slot_old{slot.load(std::memory_order_acquire)};
+    if (slot_old.IsInvalid() || slot_old.IsInWriting())
+    {
+        return false;
+    }
+
+    const auto new_refcount = static_cast<EventSlotStatus::SubscriberCount>(slot_old.GetReferenceCount() + 1U);
+    EventSlotStatus slot_new{slot_old.GetTimeStamp(), new_refcount};
+
+    auto slot_old_value = static_cast<EventSlotStatus::value_type&>(slot_old);
+    auto slot_new_value = static_cast<EventSlotStatus::value_type&>(slot_new);
+    return AtomicIndirectorType<EventSlotStatus::value_type>::compare_exchange_weak(
+        slot, slot_old_value, slot_new_value, std::memory_order_acq_rel);
+}
+
 template <template <class> class AtomicIndirectorType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
@@ -303,6 +352,53 @@ EventSlotStatus::EventTimeStamp EventDataControlCompositeImpl<AtomicIndirectorTy
     }
 }
 
+template <template <class> class AtomicIndirectorType>
+ControlSlotCompositeIndicator EventDataControlCompositeImpl<AtomicIndirectorType>::GetLatestSlot() const noexcept
+{
+    EventDataControl* control = (asil_b_control_ != nullptr) ? asil_b_control_ : asil_qm_control_;
+
+    for (std::size_t retry_counter{0U}; retry_counter < MAX_MULTI_ALLOCATE_RETRY_COUNT; ++retry_counter)
+    {
+        const auto latest_slot_index = FindLatestReadableSlotIndex(*control);
+
+        if (!latest_slot_index.has_value())
+        {
+            return {};
+        }
+
+        const auto slot_index = latest_slot_index.value();
+
+        if (asil_b_control_ != nullptr)
+        {
+            auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+            auto& slot_asil_b = asil_b_control_->state_slots_[slot_index];
+
+            if (!TryIncreaseReferenceCount(slot_qm))
+            {
+                continue;
+            }
+
+            if (!TryIncreaseReferenceCount(slot_asil_b))
+            {
+                score::cpp::ignore = slot_qm.fetch_sub(1U, std::memory_order_acq_rel);
+                continue;
+            }
+
+            return {slot_index, slot_qm, slot_asil_b};
+        }
+
+        auto& slot_qm = asil_qm_control_->state_slots_[slot_index];
+        if (!TryIncreaseReferenceCount(slot_qm))
+        {
+            continue;
+        }
+
+        return {slot_index, slot_qm, ControlSlotCompositeIndicator::CompositeSlotTagType::QM};
+    }
+
+    return {};
+}
+
 template <template <class> class AtomicIndirectorType>
 void EventDataControlCompositeImpl<AtomicIndirectorType>::CheckForValidDataControls() const noexcept
 {
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite.h b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
index c052bedf0..5efba2cf1 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite.h
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite.h
@@ -98,6 +98,8 @@ class EventDataControlCompositeImpl
     /// \brief Returns the timestamp of the provided slot index
     EventSlotStatus::EventTimeStamp GetEventSlotTimestamp(const SlotIndexType slot) const noexcept;
 
+    ControlSlotCompositeIndicator GetLatestSlot() const noexcept;
+
     EventSlotStatus::EventTimeStamp GetLatestTimestamp() const noexcept;
 
   private:
@@ -110,8 +112,10 @@ class EventDataControlCompositeImpl
 
     // Algorithms that operate on multiple control blocks
     ControlSlotCompositeIndicator GetNextFreeMultiSlot() const noexcept;
+    score::cpp::optional<SlotIndexType> FindLatestReadableSlotIndex(const EventDataControl& control) const noexcept;
 
     bool TryLockSlot(ControlSlotCompositeIndicator slot_indicator) noexcept;
+    bool TryIncreaseReferenceCount(ControlSlotType& slot) const noexcept;
     ControlSlotCompositeIndicator AllocateNextMultiSlot() noexcept;
     void CheckForValidDataControls() const noexcept;
 };
diff --git a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
index 3f046d58f..7ca576cf3 100644
--- a/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
+++ b/score/mw/com/impl/bindings/lola/event_data_control_composite_test.cpp
@@ -202,6 +202,73 @@ TEST_F(EventDataControlCompositeFixture, GetLatestTimeStampReturnCorrectValue)
     EXPECT_EQ(time_stamp_obtained, time_stamp);
 }
 
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsLatestReadySlotForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and two ready slots
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto first_slot = unit_->AllocateNextSlot();
+    auto second_slot = unit_->AllocateNextSlot();
+    unit_->EventReady(first_slot, 2U);
+    unit_->EventReady(second_slot, 3U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot with the highest timestamp is returned
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    EXPECT_EQ(latest_slot.GetIndex(), second_slot.GetIndex());
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmOnly)
+{
+    // Given an EventDataControlComposite with QM-only control and one ready slot
+    WithQmOnlyEventDataControl().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then the slot is referenced once
+    ASSERT_TRUE(latest_slot.IsValidQM());
+    const EventSlotStatus slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    EXPECT_EQ(slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotIncrementsReferenceCountForQmAndAsilB)
+{
+    // Given an EventDataControlComposite with QM and ASIL-B controls and one ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    auto slot = unit_->AllocateNextSlot();
+    unit_->EventReady(slot, 2U);
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then both control parts are referenced once
+    ASSERT_TRUE(latest_slot.IsValidQmAndAsilB());
+    const EventSlotStatus qm_slot_status{latest_slot.GetSlotQM().load(std::memory_order_acquire)};
+    const EventSlotStatus asil_b_slot_status{latest_slot.GetSlotAsilB().load(std::memory_order_acquire)};
+    EXPECT_EQ(qm_slot_status.GetReferenceCount(), 1U);
+    EXPECT_EQ(asil_b_slot_status.GetReferenceCount(), 1U);
+}
+
+TEST_F(EventDataControlCompositeFixture, GetLatestSlotReturnsInvalidIndicatorIfNoReadableSlotExists)
+{
+    // Given an EventDataControlComposite with no ready slot
+    WithQmAndAsilBEventDataControls().WithRealEventDataControlComposite();
+
+    // When acquiring the latest slot
+    const auto latest_slot = unit_->GetLatestSlot();
+
+    // Then no valid slot is returned
+    EXPECT_FALSE(latest_slot.IsValidQM());
+    EXPECT_FALSE(latest_slot.IsValidAsilB());
+}
+
 TEST_F(EventDataControlCompositeFixture, CanAllocateMultipleSlots)
 {
     // Given an EventDataControlComposite with zero used slots
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event.h b/score/mw/com/impl/bindings/lola/skeleton_event.h
index c0bca4719..63869aafa 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event.h
+++ b/score/mw/com/impl/bindings/lola/skeleton_event.h
@@ -91,6 +91,8 @@ class SkeletonEvent final : public SkeletonEventBinding<SampleType>
 
     Result<impl::SampleAllocateePtr<SampleType>> Allocate() noexcept override;
 
+    Result<SampleType> GetLatestSample() noexcept override;
+
     /// @requirement SWS_CM_00700
     ResultBlank PrepareOffer() noexcept override;
 
@@ -233,7 +235,8 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
 {
     if (event_data_control_composite_.has_value() == false)
     {
-        ::score::mw::log::LogError("lola") << "Tried to allocate event, but the EventDataControl does not exist!";
+        ::score::mw::log::LogError("lola")
+            << "Tried to allocate event, but the EventDataControlComposite does not exist!";
         return MakeUnexpected(ComErrc::kBindingFailure);
     }
     const auto slot = event_data_control_composite_->AllocateNextSlot();
@@ -272,6 +275,38 @@ Result<impl::SampleAllocateePtr<SampleType>> SkeletonEvent<SampleType>::Allocate
     }
 }
 
+template <typename SampleType>
+Result<SampleType> SkeletonEvent<SampleType>::GetLatestSample() noexcept
+{
+    if (event_data_control_composite_.has_value() == false)
+    {
+        ::score::mw::log::LogError("lola")
+            << "Tried to get the latest sample, but the EventDataControlComposite does not exist!";
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+    auto slot = event_data_control_composite_->GetLatestSlot();
+
+    if (slot.IsValidQM() || slot.IsValidAsilB())
+    {
+        const auto sample = event_data_storage_->at(static_cast<std::uint64_t>(slot.GetIndex()));
+
+        if (slot.IsValidQM())
+        {
+            score::cpp::ignore = slot.GetSlotQM().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+        if (slot.IsValidAsilB())
+        {
+            score::cpp::ignore = slot.GetSlotAsilB().fetch_sub(1U, std::memory_order_acq_rel);
+        }
+
+        return sample;
+    }
+    else
+    {
+        return MakeUnexpected(ComErrc::kBindingFailure);
+    }
+}
+
 template <typename SampleType>
 // Suppress "AUTOSAR C++14 A15-5-3" rule findings. This rule states: "The std::terminate() function shall not be called
 // implicitly". This is a false positive, all results which are accessed with '.value()' that could implicitly call
diff --git a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
index 8827bfa08..e07306e15 100644
--- a/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
+++ b/score/mw/com/impl/bindings/lola/skeleton_event_test.cpp
@@ -318,6 +318,56 @@ TEST_F(SkeletonEventPrepareStopOfferFixture, StopOfferSkeletonEvent)
     skeleton_event_->PrepareStopOffer();
 }
 
+using SkeletonEventGetLatestSampleFixture = SkeletonEventFixture;
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsBeforePrepareOffer)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleFailsIfNoSampleWasSent)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_FALSE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.error(), ComErrc::kBindingFailure);
+}
+
+TEST_F(SkeletonEventGetLatestSampleFixture, GetLatestSampleReturnsMostRecentlySentSample)
+{
+    const bool enforce_max_samples{true};
+    InitialiseSkeletonEvent(fake_element_fq_id_, fake_event_name_, max_samples_, max_subscribers_, enforce_max_samples);
+    std::ignore = skeleton_event_->PrepareOffer();
+
+    auto first_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(first_allocated_slot_result.has_value());
+    auto first_allocated_slot = std::move(first_allocated_slot_result).value();
+    *first_allocated_slot = static_cast<test::TestSampleType>(11U);
+    auto first_send_result = skeleton_event_->Send(std::move(first_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(first_send_result.has_value());
+
+    auto second_allocated_slot_result = skeleton_event_->Allocate();
+    ASSERT_TRUE(second_allocated_slot_result.has_value());
+    auto second_allocated_slot = std::move(second_allocated_slot_result).value();
+    *second_allocated_slot = static_cast<test::TestSampleType>(42U);
+    auto second_send_result = skeleton_event_->Send(std::move(second_allocated_slot), score::cpp::nullopt);
+    ASSERT_TRUE(second_send_result.has_value());
+
+    const auto latest_sample = skeleton_event_->GetLatestSample();
+
+    ASSERT_TRUE(latest_sample.has_value());
+    EXPECT_EQ(latest_sample.value(), static_cast<test::TestSampleType>(42U));
+}
+
 using SkeletonEventTimestampFixture = SkeletonEventFixture;
 TEST_F(SkeletonEventTimestampFixture, SendUpdatesTimestampInControlData)
 {
diff --git a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
index c08e21d16..b6f089a74 100644
--- a/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
+++ b/score/mw/com/impl/bindings/mock_binding/skeleton_event.h
@@ -48,6 +48,7 @@ class SkeletonEvent : public SkeletonEventBinding<SampleType>
                  score::cpp::optional<typename SkeletonEventBinding<SampleType>::SendTraceCallback>),
                 (noexcept, override));
     MOCK_METHOD(Result<SampleAllocateePtr<SampleType>>, Allocate, (), (noexcept, override));
+    MOCK_METHOD(Result<SampleType>, GetLatestSample, (), (noexcept, override));
     MOCK_METHOD(ResultBlank, PrepareOffer, (), (noexcept, override));
     MOCK_METHOD(void, PrepareStopOffer, (), (noexcept, override));
     MOCK_METHOD(std::size_t, GetMaxSize, (), (const, noexcept, override));
@@ -83,6 +84,10 @@ class SkeletonEventFacade : public SkeletonEventBinding<SampleType>
     {
         return skeleton_event_.Allocate();
     };
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return skeleton_event_.GetLatestSample();
+    }
     ResultBlank PrepareOffer() noexcept override
     {
         return skeleton_event_.PrepareOffer();
diff --git a/score/mw/com/impl/skeleton_event.h b/score/mw/com/impl/skeleton_event.h
index 2face4332..722b9fc1f 100644
--- a/score/mw/com/impl/skeleton_event.h
+++ b/score/mw/com/impl/skeleton_event.h
@@ -313,6 +313,11 @@ class SkeletonEventView
         return skeleton_event_.GetTypedEventBinding();
     }
 
+    Result<SampleType> GetLatestSample() noexcept
+    {
+        return GetBinding()->GetLatestSample();
+    }
+
   private:
     SkeletonEvent<SampleType>& skeleton_event_;
 };
diff --git a/score/mw/com/impl/skeleton_event_binding.h b/score/mw/com/impl/skeleton_event_binding.h
index 7255ab8f1..198f7d153 100644
--- a/score/mw/com/impl/skeleton_event_binding.h
+++ b/score/mw/com/impl/skeleton_event_binding.h
@@ -89,6 +89,8 @@ class SkeletonEventBinding : public SkeletonEventBindingBase
     /// implementations.
     virtual Result<SampleAllocateePtr<SampleType>> Allocate() noexcept = 0;
 
+    virtual Result<SampleType> GetLatestSample() noexcept = 0;
+
     std::size_t GetMaxSize() const noexcept override
     {
         return sizeof(SampleType);
diff --git a/score/mw/com/impl/skeleton_event_binding_test.cpp b/score/mw/com/impl/skeleton_event_binding_test.cpp
index cb32d56e1..5e0461eac 100644
--- a/score/mw/com/impl/skeleton_event_binding_test.cpp
+++ b/score/mw/com/impl/skeleton_event_binding_test.cpp
@@ -48,6 +48,10 @@ class MyEvent final : public SkeletonEventBinding<SampleType>
     {
         return MakeSampleAllocateePtr(std::make_unique<SampleType>());
     }
+    Result<SampleType> GetLatestSample() noexcept override
+    {
+        return SampleType{};
+    }
     BindingType GetBindingType() const noexcept override
     {
         return BindingType::kFake;
diff --git a/score/mw/com/impl/skeleton_event_test.cpp b/score/mw/com/impl/skeleton_event_test.cpp
index 1db0646b6..9bde6ac75 100644
--- a/score/mw/com/impl/skeleton_event_test.cpp
+++ b/score/mw/com/impl/skeleton_event_test.cpp
@@ -653,5 +653,61 @@ TEST(SkeletonEventTest, MovingAssigningSkeletonUpdatesEventMapReference)
     EXPECT_EQ(&event, &unit2.my_dummy_event_);
 }
 
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleDispatchesToBinding)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+    // and that GetLatestSample() is called once on the event binding which returns a valid sample
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(static_cast<TestSampleType>(42U))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result is valid and contains the sample from the binding
+    ASSERT_TRUE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.value(), static_cast<TestSampleType>(42U));
+}
+
+TEST(SkeletonEventGetLatestSampleTest, CallingGetLatestSampleWhenBindingFailsReturnsError)
+{
+    RuntimeMockGuard runtime_mock_guard{};
+    ON_CALL(runtime_mock_guard.runtime_mock_, GetTracingFilterConfig()).WillByDefault(Return(nullptr));
+    SkeletonEventBindingFactoryMockGuard<TestSampleType> skeleton_event_binding_factory_mock_guard{};
+
+    // Expecting that a SkeletonEvent binding is created
+    auto skeleton_event_binding_mock_ptr = std::make_unique<mock_binding::SkeletonEvent<TestSampleType>>();
+    auto& skeleton_event_binding_mock = *skeleton_event_binding_mock_ptr;
+    EXPECT_CALL(skeleton_event_binding_factory_mock_guard.factory_mock_,
+                Create(kInstanceIdWithLolaBinding, _, kEventName))
+        .WillOnce(Return(ByMove(std::move(skeleton_event_binding_mock_ptr))));
+
+    // and that GetLatestSample() is called once on the event binding which returns an error
+    EXPECT_CALL(skeleton_event_binding_mock, GetLatestSample())
+        .WillOnce(Return(ByMove(MakeUnexpected(ComErrc::kBindingFailure))));
+
+    // Given a skeleton which has a mock skeleton-binding
+    MyDummySkeleton unit{std::make_unique<mock_binding::Skeleton>(), kInstanceIdWithLolaBinding};
+
+    // When calling GetLatestSample on the event
+    const auto latest_sample_result = SkeletonEventView<TestSampleType>{unit.my_dummy_event_}.GetLatestSample();
+
+    // Then the result contains an error that the binding failed
+    ASSERT_FALSE(latest_sample_result.has_value());
+    EXPECT_EQ(latest_sample_result.error(), ComErrc::kBindingFailure);
+}
+
 }  // namespace
 }  // namespace score::mw::com::impl