@@ -130,15 +130,11 @@ static bool IsPreferred(ClusterState state, TargetSessionAttributes preferredTyp
             _ => preferredType == TargetSessionAttributes.Any
         };
 
-    static bool IsFallbackOrPreferred(ClusterState state, TargetSessionAttributes preferredType)
-        => state switch
-        {
-            ClusterState.Unknown => true, // We will check compatibility again after refreshing the cluster state
-            ClusterState.PrimaryReadWrite when preferredType == TargetSessionAttributes.PreferPrimary || preferredType == TargetSessionAttributes.PreferStandby => true,
-            ClusterState.PrimaryReadOnly when preferredType == TargetSessionAttributes.PreferPrimary || preferredType == TargetSessionAttributes.PreferStandby => true,
-            ClusterState.Standby when preferredType == TargetSessionAttributes.PreferPrimary || preferredType == TargetSessionAttributes.PreferStandby => true,
-            _ => false
-        };
+    static bool IsOnline(ClusterState state, TargetSessionAttributes preferredType)
+    {
+        Debug.Assert(preferredType is TargetSessionAttributes.PreferPrimary or TargetSessionAttributes.PreferStandby);
+        return state != ClusterState.Offline;
+    }
 
     static ClusterState GetClusterState(NpgsqlDataSource pool, bool ignoreExpiration = false)
         => GetClusterState(pool.Settings.Host!, pool.Settings.Port, ignoreExpiration);
@@ -277,11 +273,11 @@ internal override async ValueTask<NpgsqlConnector> Get(NpgsqlConnection conn, Np
 
         var connector = await TryGetIdleOrNew(conn, timeoutPerHost, async, preferredType, IsPreferred, poolIndex, exceptions, cancellationToken) ??
                         (checkUnpreferred ?
-                            await TryGetIdleOrNew(conn, timeoutPerHost, async, preferredType, IsFallbackOrPreferred, poolIndex, exceptions, cancellationToken)
+                            await TryGetIdleOrNew(conn, timeoutPerHost, async, preferredType, IsOnline, poolIndex, exceptions, cancellationToken)
                             : null) ??
                         await TryGet(conn, timeoutPerHost, async, preferredType, IsPreferred, poolIndex, exceptions, cancellationToken) ??
                         (checkUnpreferred ?
-                            await TryGet(conn, timeoutPerHost, async, preferredType, IsFallbackOrPreferred, poolIndex, exceptions, cancellationToken)
+                            await TryGet(conn, timeoutPerHost, async, preferredType, IsOnline, poolIndex, exceptions, cancellationToken)
                             : null);
 
         if (connector is not null)
@@ -366,13 +362,33 @@ internal override bool TryRentEnlistedPending(Transaction transaction, NpgsqlCon
                 return false;
             }
 
+            var preferredType = GetTargetSessionAttributes(connection);
+            // First try to get a valid preferred connector.
+            if (TryGetValidConnector(list, preferredType, IsPreferred, out connector))
+            {
+                return true;
+            }
+
+            // Can't get valid preferred connector. Try to get an unpreferred connector, if supported.
+            if ((preferredType == TargetSessionAttributes.PreferPrimary || preferredType == TargetSessionAttributes.PreferStandby)
+                && TryGetValidConnector(list, preferredType, IsOnline, out connector))
+            {
+                return true;
+            }
+
+            connector = null;
+            return false;
+        }
+
+        bool TryGetValidConnector(List<NpgsqlConnector> list, TargetSessionAttributes preferredType,
+            Func<ClusterState, TargetSessionAttributes, bool> validationFunc, [NotNullWhen(true)] out NpgsqlConnector? connector)
+        {
             for (var i = list.Count - 1; i >= 0; i--)
             {
                 connector = list[i];
                 var lastKnownState = GetClusterState(connector.Host, connector.Port, ignoreExpiration: true);
                 Debug.Assert(lastKnownState != ClusterState.Unknown);
-                var preferredType = GetTargetSessionAttributes(connection);
-                if (IsFallbackOrPreferred(lastKnownState, preferredType))
+                if (validationFunc(lastKnownState, preferredType))
                 {
                     list.RemoveAt(i);
                     if (list.Count == 0)
@@ -388,7 +404,7 @@ internal override bool TryRentEnlistedPending(Transaction transaction, NpgsqlCon
 
     static TargetSessionAttributes GetTargetSessionAttributes(NpgsqlConnection connection)
         => connection.Settings.TargetSessionAttributesParsed ??
-           (PostgresEnvironment.TargetSessionAttributes is string s
+           (PostgresEnvironment.TargetSessionAttributes is { } s
                ? NpgsqlConnectionStringBuilder.ParseTargetSessionAttributes(s)
                : TargetSessionAttributes.Any);
 }
@@ -15,6 +15,8 @@
 using Npgsql.Properties;
 using static Npgsql.Tests.Support.MockState;
 using static Npgsql.Tests.TestUtil;
+using IsolationLevel = System.Transactions.IsolationLevel;
+using TransactionStatus = Npgsql.Internal.TransactionStatus;
 
 namespace Npgsql.Tests;
 
@@ -160,84 +162,6 @@ public async Task Valid_host_not_found(string targetSessionAttributes, MockState
             _ = await postmasters[i].WaitForServerConnection();
     }
 
-    [Test]
-    [Description("Test that enlist returns a new connector if a previous connector is for an incompatible server type")]
-    public async Task Enlist_depends_on_session_attributes()
-    {
-        await using var primaryPostmaster = PgPostmasterMock.Start(state: Primary);
-        await using var standbyPostmaster = PgPostmasterMock.Start(state: Standby);
-
-        var defaultCsb = new NpgsqlConnectionStringBuilder
-        {
-            Host = MultipleHosts(primaryPostmaster, standbyPostmaster),
-            ServerCompatibilityMode = ServerCompatibilityMode.NoTypeLoading,
-            Enlist = true,
-        };
-
-        using var _ = CreateTempPool(defaultCsb.ConnectionString, out var defaultConnectionString);
-
-        var primaryCsb = new NpgsqlConnectionStringBuilder(defaultConnectionString)
-        {
-            TargetSessionAttributes = "primary",
-        };
-
-        var standbyCsb = new NpgsqlConnectionStringBuilder(defaultConnectionString)
-        {
-            TargetSessionAttributes = "standby",
-        };
-
-        var preferPrimaryCsb = new NpgsqlConnectionStringBuilder(defaultConnectionString)
-        {
-            TargetSessionAttributes = "prefer-primary",
-        };
-
-        var preferStandbyCsb = new NpgsqlConnectionStringBuilder(defaultConnectionString)
-        {
-            TargetSessionAttributes = "prefer-standby",
-        };
-
-        // Note that the transaction scope is not disposed due to a rollback (which isn't something a mock expects)
-        var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
-
-        NpgsqlConnector primaryConnector;
-        NpgsqlConnector standbyConnector;
-
-        using (var primaryConnection = await OpenConnectionAsync(primaryCsb.ConnectionString))
-        {
-            primaryConnector = primaryConnection.Connector!;
-        }
-
-        using (var preferPrimaryConnection = await OpenConnectionAsync(preferPrimaryCsb.ConnectionString))
-        {
-            Assert.AreSame(primaryConnector, preferPrimaryConnection.Connector);
-        }
-
-        using (var preferStandbyConnection = await OpenConnectionAsync(preferStandbyCsb.ConnectionString))
-        {
-            Assert.AreSame(primaryConnector, preferStandbyConnection.Connector);
-        }
-
-        using (var standbyConnection = await OpenConnectionAsync(standbyCsb.ConnectionString))
-        {
-            standbyConnector = standbyConnection.Connector!;
-        }
-
-        using (var preferPrimaryConnection = await OpenConnectionAsync(preferPrimaryCsb.ConnectionString))
-        {
-            Assert.AreSame(standbyConnector, preferPrimaryConnection.Connector);
-        }
-
-        using (var preferStandbyConnection = await OpenConnectionAsync(preferStandbyCsb.ConnectionString))
-        {
-            Assert.AreSame(standbyConnector, preferStandbyConnection.Connector);
-        }
-
-        Assert.AreNotSame(primaryConnector, standbyConnector);
-
-        await primaryPostmaster.WaitForServerConnection();
-        await standbyPostmaster.WaitForServerConnection();
-    }
-
     [Test, Platform(Exclude = "MacOsX", Reason = "#3786")]
     public void All_hosts_are_down()
     {
@@ -836,6 +760,75 @@ public async Task Clear_pool_one_host_only_on_admin_shutdown()
         Assert.That(primaryConn.NpgsqlDataSource.Statistics.Total, Is.EqualTo(1));
     }
 
+    [Test]
+    [TestCase("any", true)]
+    [TestCase("primary", true)]
+    [TestCase("standby", false)]
+    [TestCase("prefer-primary", true)]
+    [TestCase("prefer-standby", false)]
+    [TestCase("read-write", true)]
+    [TestCase("read-only", false)]
+    public async Task Transaction_enlist_reuses_connection(string targetSessionAttributes, bool primary)
+    {
+        await using var primaryPostmaster = PgPostmasterMock.Start(ConnectionString, state: Primary);
+        await using var standbyPostmaster = PgPostmasterMock.Start(ConnectionString, state: Standby);
+        var csb = new NpgsqlConnectionStringBuilder
+        {
+            Host = MultipleHosts(primaryPostmaster, standbyPostmaster),
+            TargetSessionAttributes = targetSessionAttributes,
+            ServerCompatibilityMode = ServerCompatibilityMode.NoTypeLoading,
+            MaxPoolSize = 10,
+        };
+
+        using var _ = CreateTempPool(csb, out var connString);
+
+        using var scope = new TransactionScope(TransactionScopeOption.Required,
+            new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }, TransactionScopeAsyncFlowOption.Enabled);
+
+        var query1Task = Query(connString);
+
+        var server = primary
+            ? await primaryPostmaster.WaitForServerConnection()
+            : await standbyPostmaster.WaitForServerConnection();
+
+        await server
+            .WriteCommandComplete()
+            .WriteReadyForQuery(TransactionStatus.InTransactionBlock)
+            .WriteParseComplete()
+            .WriteBindComplete()
+            .WriteNoData()
+            .WriteCommandComplete()
+            .WriteReadyForQuery(TransactionStatus.InTransactionBlock)
+            .FlushAsync();
+        await query1Task;
+
+        var query2Task = Query(connString);
+        await server
+            .WriteParseComplete()
+            .WriteBindComplete()
+            .WriteNoData()
+            .WriteCommandComplete()
+            .WriteReadyForQuery(TransactionStatus.InTransactionBlock)
+            .FlushAsync();
+        await query2Task;
+
+        await server
+            .WriteCommandComplete()
+            .WriteReadyForQuery()
+            .FlushAsync();
+        scope.Complete();
+
+        async Task Query(string connectionString)
+        {
+            await using var conn = new NpgsqlConnection(connectionString);
+            await conn.OpenAsync();
+
+            await using var cmd = conn.CreateCommand();
+            cmd.CommandText = "SELECT 1";
+            await cmd.ExecuteNonQueryAsync();
+        }
+    }
+
     // This is the only test in this class which actually connects to PostgreSQL (the others use the PostgreSQL mock)
     [Test, NonParallelizable]
     public void IntegrationTest([Values] bool loadBalancing, [Values] bool alwaysCheckHostState)