
<p class="has-drop-cap">1 Ett snabblopp med norrlandseliten spetsad med en segervan finsk gäst kan bli kvällens höjdare. Skådeplatsen är Boden (första start 18.20) och sprinterloppet är utskrivet som en spårtrappa, där <strong>From The Mine</strong> (e. From Above) och <strong>Selmer I.H. </strong>(e. Love You) har de tjockaste plånböckerna. Hästarna har mötts åtta gånger och det är 5-3 i inbördes möten i Selmer I.H:s favör.<br>Duon inleder från spår sju och åtta och längre ned bakom startbilsvingen finns formstarke finländaren <strong>No Limit Royalty</strong> (e. R.C.Royalty) som vunnit tolv lopp i år på 25 starter. Dessutom blir det efterlängtad comeback av Sandra Erikssons topphäst <strong>Swagger</strong> (e. Zola Boko), som inte startat sedan i december förra året.</p>



<p>Ponsse Cup är en serie för tre- och fyraåringar i låg klass (högst 150.000 kronor) med fem försök, varifrån de två främsta går till final i Uleåborg den 23 december med 12.000 euro i förstapris.<br>Två försök vardera körs i Uleåborg och Kuopio, medan ett avgörs på svensk mark i Boden och ikväll är det dags. Kapable men galoppbenägne <strong>Mas Gunnar</strong> (e. Jontte Boy) är en av tre finsktränade hästar som ska försöka hindra nio svenskar från finalplatser i Uleåborg.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2 Boden delar kvällens expresstrav med Bollnäs (start 18.30) och där ska banans bästa – nåja – hästar koras. Det handlar om Bollnäsmästaren för både varm- och kallblod med 50.000 kronor i förstapris i varje.<br>Det bjuds stora fält med hästar på flera volter i de båda loppen som är förbehållna Bollnästränade travare. I kallblodsklassen skiljer 100 meter från start mellan duon <strong>Klack Astrid</strong> (e. Bork Odin) och <strong>Pyssla</strong> (e. Smedheim Solan) och längst bak startande <strong>Höstbo Elis</strong> (e. Tekno Odin).<br>Tre volter handlar det om bland varmbloden, där Stefan Arvidsson har en god duo i <strong>One Crystal</strong> (e. One Too Many) och <strong>Axl Brown</strong> (e. Maharajah), som bland annat ställs mot tre hästar från Thomas Lönns stall.</p>



<p>Eskilstuna (start 12.20) inleder dagen med lunchtävlingar. Daniel Redéns Derbystofinalist <strong>Mi Amore Bros</strong> (e. Propulsion) möter bland annat stallkamraten <strong>Global Delight</strong> (e. Propulsion) och flera andra fina ston i ett stolopp stängt vid 475.000 kronor.</p>



<p>Fredagen bjuder även på breddtrav i Kalmar (start 18.30).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/11/231117.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3 Två svenskfödda hästar kommer till start i kvällens Quinté-lopp Prix Mizar (€53.000) på Vincennes (första start kl. 18.58).<br>Jörgen Westholm luftar <strong>Santos de Castella </strong>(e. Readly Express) i lag med Eric Raffin, men än mer betrodd lär Vincent Martens blågule <strong>King Cole</strong> (e. Maharajah) bli i lag med Christophe Martens.</p>



<p>Den forne Daniel Wäjersten-springaren vann på Vincennes i juni och kommer närmast från segerlopp i Cagnes-sur-Mer och La Capelle.</p>



<p>I Mauquenchy (första start kl. 16.00) tävlar tre svensktränade hästar. Jarmo Niskanen är först ut med treårige <strong>Kotesit</strong> (e. Captain Sparrow) i Prix Jean Lapierre (€13.000) vilken sällskapas av Ron Kuipers <strong>Jizzy Dream </strong>(e. Cristal Money) och Björn Goops <strong>Javlar</strong> (e. Charly du Noyer) i Prix de Buchy (€13.000).<br>Den sistnämnde körs därtill av svenske Johan L Sundgren som nu jagar sin första kuskseger i Frankrike i sitt tionde försök.</p>



<p><strong>Så gick det för gårdagens svenskhopp på Vincennes:</strong><br><em>Hästnamn (far) – Tränare – Placering – Prispengar</em></p>



<ul class="wp-block-list">
<li><strong>Self Explosive</strong> (e. Explosive Matter) – Christoffer Eriksson – trea – 12.600 euro</li>



<li><strong>Nymke Brigadoon</strong> (e. Make It Happen) – Björn Goop – femma – 2.300 euro</li>



<li><strong>Beauty Wind</strong> (e. Muscle Hill) – Björn Goop – opl – 0 euro</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4På lördag på Meadowlands hålls försök till de två sista storloppen för tvååringarna för säsongen och det handlar om Goldsmith Maid ($20.000) för stona, medan hingstarna/valackerna gör upp i Valley Victory ($20.000). Finalerna i de båda löpningarna avgörs den 25 november med 415.000 dollar i totalprissumma i Goldsmith Maid och 410.000 dollar i Valley Victory.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/soireehanoverttm231007adamstromstalltz-617x416.jpg" alt="" class="wp-image-506514"/><figcaption class="wp-element-caption">Snogarps Gårds Soiree Hanover kvalar till Goldsmith Maid på lördag. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Intresset från svenskt håll är stort. I det första försöket i Goldsmith Maid startar Lucas Wallin sin stjärna <strong>Soiree Hanover</strong> (e. Walner) och i samma lopp tar Åke Svanstedt ut <strong>Pisco Sour</strong> (e. Walner).</p>



<p>I det andra försöket i Goldsmith Maid dyker fyra svensktränade travare upp: Marcus Melanders <strong>Date Night Hanover </strong>(e. Chapter Seven), Åke Svanstedts <strong>French Champagne</strong> (e. Muscle Hill), Nancy Takters <strong>Ice Cream</strong> (e. Walner) och Lucas Wallins <strong>Tequini Hanover</strong> (e. Bar Hopping).</p>



<p>Valley Victory har fått ihop ett försök. Från Åke Svanstedts stall selas det ut tre hästar – svenskfödda duon <strong>Flying Kronos</strong> (e. Face Time Bourbon), <strong>Tony Adams</strong> (e. Muscle Hill) och <strong>Daiquiri Hanover</strong> (e. Bar Hopping) – medan Jenny Melander startar <strong>Nottingham </strong>(e. E L Titan), Marcus Melander plockar ut<strong> Wild Ticket</strong> (e. Chapter Seven) och Lucas Wallins bidrag blir <strong>Mosquito </strong>(e. Muscle Hill).</p>



<p>Åtta finalplatser står på spel sedan Nancy Takters <strong>Karl</strong> (e. Tactical Landing) och Marcus Melanders <strong>Security Protected </strong>(e. Father Patrick) erbjudits – och tackat ja! – att gå direkt till final.</p>



<p><a href="https://racing.ustrotting.com/goto.aspx?target=12,92792" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,92792" target="_blank" rel="noreferrer noopener">Samtliga startlistor till Meadowlands på lördag hittar ni här.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5Från Jägersro till Solvalla till&#8230; att bli kallblodstränare! Conrad Lugauer har numera den sjuårige miljonären <strong>Buska Blyg</strong> (e. Järvsöviking) 1.22,4ak/1.186.500 kr på sin träningslista.</p>



<p>Hingsten har tjänat över 300.000 kronor de två senaste säsongerna, men i år har han haft det desto tyngre och bara nått upp i 114.000 kronor under 16 starter i vilka det som bäst blivit två andraplatser.</p>



<p>Buska Blyg är en Menhammar-produkt och halvbror till unghäststjärnan <strong>Uggla I Mossen</strong> (e. Järvsöfaks) 1.24,2m/1.932.686 kr.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6 Hambletonian-vinnaren <strong>Tactical Approach</strong> (e. Tactical Landing), 1.08,5*/$1.422.239, har ett lopp kvar i karriären innan han övergår till avel, men innan dess ska Nancy Takters stortravare ut i ett kval på <a rel="noreferrer noopener" href="https://racing.ustrotting.com/goto.aspx?target=12,92791" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,92791" target="_blank">Meadowlands</a> på lördag.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/wb042823r2tacticalapproach-617x346.jpg" alt="" class="wp-image-437443"/><figcaption class="wp-element-caption">Tactical Approach och Scott Zeron på Meadowlands tidigare i år. Foto: Lisa Photo</figcaption></figure>



<p>Sista starten är planerad i Fanduel Championship ($350.000) för treåriga och äldre travare på Meadowlands den 25 november. Sedan väntar avel på Diamond Creek Farm i Pennsylvania och prislappen är satt till 12.500 dollar.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7En stor internetauktionshelg väntar i Sverige och först ut är ASVT ikväll. 14 hästar finns med i den digitala katalogen varav tolv av dem är fölston. Ett av dessa är <strong>J.J. </strong>(e. Jocose), 1.11,9ak/833.414 kr, som är dräktig med Cantab Hall. Ett annat är Iris Palema (e. Symphonic Hanover), 1.13,5m/394.100 kr, som är dräktig med San Moteur.<br>Dessutom säljs i paket stoet <strong>Approach Reference</strong> (e. Scarlet Knight) och hennes föl med <strong>In Range</strong> (e. Bar Hopping) som far vid sidan.</p>



<p>En starthäst samt en ettåring (e. Tobin Kronos) från <strong>Viva la Differences</strong> möderne bjuds också ut.</p>



<p><a href="https://auktion.asvt.se/purchase" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällens auktion med start kl 19.00.</a></p>

Fokustema
Morgonsvepet
Läs senare
Efterlängtad comeback
Om en profilhästs efterlängtade comeback, svenskhopp på Vincennes och en kallblodig miljonär som anslutit till Conrad Lugauers stall går bland annat att läsa i veckans femte morgonsvep.
