@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import warnings
 from copy import deepcopy
 
@@ -22,6 +23,8 @@
 
 __all__ = ["ExperimentsToSbmlConverter"]
 
+logger = logging.getLogger(__name__)
+
 
 class ExperimentsToSbmlConverter:
     """Convert PEtab experiments to SBML.
@@ -34,6 +37,10 @@ class ExperimentsToSbmlConverter:
     are applied before any pre-existing assignments.
     This requires that all event priorities in the original model are numeric
     constants.
+    If exactly one pre-existing event has no priority, it is assigned a
+    priority lower than all other priorities in the model.
+    If multiple events have no priority, their order relative to the PEtab
+    events is undefined, unless ``default_priority`` is provided.
 
     The PEtab problem must not contain any identifiers starting with
     ``_petab``.
@@ -73,6 +80,11 @@ def __init__(self, problem: Problem, default_priority: float = None):
             See SBML specs for details.
             To ensure that the PEtab condition-start-events are executed before
             any other events, all events should have a priority set.
+            Note that, according to the SBML specs, events with equal
+            priorities that are executed simultaneously must be executed in
+            random order.
+            If ``None``, a priority is only assigned automatically if exactly
+            one pre-existing event has no priority.
         """
         if len(problem.models) > 1:
             #  https://github.com/PEtab-dev/libpetab-python/issues/392
@@ -121,14 +133,13 @@ def _preprocess(self) -> None:
         # Apply default priority to all events that do not have a priority
         if self._default_priority is not None:
             for event in model.getListOfEvents():
-                if (
-                    not event.getPriority()
-                    or event.getPriority().getMath() is None
-                ):
+                if not self._has_priority(event):
                     priority = event.createPriority()
                     priority.setMath(
                         libsbml.parseL3Formula(str(self._default_priority))
                     )
+        else:
+            self._auto_assign_priority()
 
         # Collect event priorities
         event_priorities = {
@@ -186,6 +197,54 @@ def _preprocess(self) -> None:
                     stacklevel=1,
                 )
 
+    @staticmethod
+    def _has_priority(event: libsbml.Event) -> bool:
+        """Check whether the given event has a priority expression."""
+        return (
+            event.isSetPriority() and event.getPriority().getMath() is not None
+        )
+
+    def _auto_assign_priority(self) -> None:
+        """Assign a priority to a single unprioritized pre-existing event.
+
+        If exactly one pre-existing event has no priority, and all other
+        events have constant priorities, the unprioritized event is assigned
+        a priority lower than any other priority in the model.
+        Without priority, the order of this event with respect to all other
+        events is undefined, so assigning a priority only selects one of the
+        admissible orders. A distinct priority cannot create ties, which
+        would require random execution order (SBML L3V2 §4.12.3). This allows
+        executing the PEtab events before this event.
+
+        If more than one event has no priority, no priority is assigned,
+        since this would impose an arbitrary order on them if they are
+        executed simultaneously.
+        """
+        events = list(self._model.getListOfEvents())
+        unprioritized = [ev for ev in events if not self._has_priority(ev)]
+        if len(unprioritized) != 1:
+            return
+
+        priorities = []
+        for ev in events:
+            if not self._has_priority(ev):
+                continue
+            priority = sbml_math_to_sympy(ev.getPriority())
+            if priority.free_symbols:
+                # handled in _preprocess
+                return
+            priorities.append(float(priority))
+
+        value = min(priorities) - 1 if priorities else 0.0
+        event = unprioritized[0]
+        priority = event.createPriority()
+        set_math(priority, value)
+        logger.debug(
+            f"Assigned priority {value} to event `{event.getId()}` to "
+            "ensure that PEtab condition changes are applied before this "
+            "event's assignments."
+        )
+
     def convert(self) -> Problem:
         """Convert the PEtab experiments to SBML events.
 
 
@@ -1,6 +1,8 @@
 from math import inf
 
 import pandas as pd
+import pytest
+from sbmlmath import sbml_math_to_sympy
 
 from petab.v2 import Change, Condition, Experiment, ExperimentPeriod, Problem
 from petab.v2.converters import ExperimentsToSbmlConverter
@@ -232,3 +234,92 @@ def test_simulate_experiment_to_events():
 
     for col in df_expected.columns:
         assert (df_expected[col] == df_actual[col]).all()
+
+
+def _event_priorities(sbml_model) -> dict[str, float | None]:
+    """Get the numeric priorities of all events in the given model."""
+    return {
+        ev.getId(): float(sbml_math_to_sympy(ev.getPriority()))
+        if ev.isSetPriority() and ev.getPriority().getMath() is not None
+        else None
+        for ev in sbml_model.getListOfEvents()
+    }
+
+
+def _problem_0030(model_events: str) -> Problem:
+    """PEtab test suite case 0030 with the given model events."""
+    ant_model = f"""
+    compartment C = 4
+    species S in C = 3
+    p = 1
+    S' = p
+    {model_events}
+    """
+    problem = Problem()
+    problem.model = SbmlModel.from_antimony(ant_model)
+    problem.add_condition("condition1", S=2)
+    problem.add_condition("condition2", S="S + C", C=8)
+    problem.add_experiment("experiment1", 0, "condition1", 10, "condition2")
+    return problem
+
+
+E0 = "E0: at time >= 10, fromTrigger=false: C = C * 2"
+E0_PRIO = "E0: at time >= 10, priority=-2, fromTrigger=false: C = C * 2"
+E1 = "E1: at time >= 20, fromTrigger=false: C = C"
+E1_PRIO = "E1: at time >= 20, priority=5, fromTrigger=false: C = C"
+PETAB_EVENT = "_petab_event_experiment1_1"
+
+
+@pytest.mark.parametrize(
+    "model_events,expected",
+    [
+        # single unprioritized event
+        (E0, {"E0": 0, PETAB_EVENT: 1}),
+        # one unprioritized event, others prioritized
+        (f"{E0}\n{E1_PRIO}", {"E0": 4, "E1": 5, PETAB_EVENT: 6}),
+        # all events prioritized: unchanged
+        (f"{E0_PRIO}\n{E1_PRIO}", {"E0": -2, "E1": 5, PETAB_EVENT: 6}),
+        # multiple unprioritized events: no automatic assignment
+        (f"{E0}\n{E1}", {"E0": None, "E1": None, PETAB_EVENT: None}),
+        # no model events
+        ("", {PETAB_EVENT: None}),
+    ],
+)
+def test_auto_event_priority(model_events, expected):
+    """Test automatic priority assignment for pre-existing events."""
+    problem = _problem_0030(model_events)
+    orig_priorities = _event_priorities(problem.model.sbml_model)
+
+    converted = ExperimentsToSbmlConverter(problem).convert()
+
+    assert _event_priorities(converted.model.sbml_model) == expected
+    # the original problem is not modified
+    assert _event_priorities(problem.model.sbml_model) == orig_priorities
+
+
+def test_auto_event_priority_empty_priority():
+    """A priority without math is treated as unset."""
+    problem = _problem_0030(E0)
+    problem.model.sbml_model.getEvent("E0").createPriority()
+
+    converted = ExperimentsToSbmlConverter(problem).convert()
+
+    assert _event_priorities(converted.model.sbml_model) == {
+        "E0": 0,
+        PETAB_EVENT: 1,
+    }
+
+
+def test_explicit_default_priority():
+    """An explicit default priority takes precedence."""
+    problem = _problem_0030(f"{E0}\n{E1}")
+
+    converted = ExperimentsToSbmlConverter(
+        problem, default_priority=3
+    ).convert()
+
+    assert _event_priorities(converted.model.sbml_model) == {
+        "E0": 3,
+        "E1": 3,
+        PETAB_EVENT: 4,
+    }