
<p class="has-drop-cap">1 År 1776 i engelska Doncaster reds S:t Leger Stakes för första gången – galoppsportens äldsta klassiska löpning var född. Officeren och politikern Anthony St Leger var mannen bakom loppet. Precis som många andra loppnamn som härstammar från galoppen har även S:t Leger hittat till travsporten i många länder.</p>



<p>För svensk del är Åby hemvist och 1967 avgjordes S:t Leger för första gången. Då som nu som ett fyraåringslopp och Berndt Lindstedt styrde vinnaren <strong>Monolog</strong> (e. Gibs Bulwark). Det kryllar av starka märken bland vinnarna i S:t Legers historia. Eller vad sägs om <strong>Ego Boy</strong>,<strong> Express Gaxe</strong>, <strong>Mustard</strong>, <strong>Callit</strong>, <strong>Queen L.</strong> och <strong>Lovely Godiva</strong> för att nämna några från förra millenniet?</p>



<p>Förutom premiärårets 2.600 meter har distansen alltid varit över tre kilometer och det är förutsättningarna även ikväll när årets upplaga avgörs med 200.000 kronor till vinnaren.</p>



<p>Sedan 2018 är propositionen ändrad från autostart till ett flerklasslopp med voltstart och tolv fyraåringar på tre volter gör upp om segern och 200.000 kronor.</p>



<p>En som redan visat att han behärskar tre kilometer är Joakim Lövgrens danske Derbyvinnare <strong>Kreadlys Lew</strong> (e. Readly Express). Denne var överlägsen när han tog hem fyraåringarnas största lopp på Charlottenlund i slutet av sommaren på 1.13,8a/3.000 meter.</p>



<p>– Jag tycker att det var hans bästa lopp i karriären som han gjorde senast. Det är en häst som är väldigt komplett och jag är nyfiken på hur bra han kan bli till nästa år, säger Joakim Lövgren till Kanal75.</p>



<p>Nu ställs han bland annat mot två finalister från svenska Derbyt i Per Nordströms <strong>Bootsman</strong> (e. Campo Bahia), som från tolftespår bakom bilen tog tredjeplatsen i travets blå band i Sverige, och <strong>Fighter Kronos</strong> (e. Muscle Hill), som reparerade stor galopp till sjätteplatsen.</p>



<h2 class="wp-block-heading">Senaste vinnarna av S:t Leger</h2>



<p><strong>År, häst (far) – Kusk (tränare) – Segertid/distans</strong></p>



<ul class="wp-block-list">
<li>2018 <strong>Vincent As</strong> (e. Muscle Massive) – Carl Johan Jepson (Magnus Dahlén) – 1.14,0/3.160</li>



<li>2019 <strong>Pinto Bob</strong> (e. Maharajah) – Robert Bergh – 1.14,3/3.180</li>



<li>2020 <strong>Power </strong>(e. Googoo Gaagaa) – Robert Bergh – 1.13,8/3.180</li>



<li>2021 <strong>Samson</strong> (e. Googoo Gaagaa) – Robert Bergh – 1.14,7/3.140</li>



<li>2022 <strong>Eagle Rock</strong> (e. S.J.’s Caviar) – Conrad Lugauer – 1.14,6/3.140</li>



<li>2023 <strong>Hustle Rain</strong> (e. Raja Mirchi) – Stefan Persson (Mattias Djuse) – 1.13,6/3.180</li>



<li>2024 <strong>Connors Broline</strong> (e. Twister Bi) – Stefan Persson (Svend Dyhrberg) – 1.14,2/3.140</li>
</ul>



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



<p class="has-drop-cap">2 Kvällens expresstrav med V86 delas mellan <strong>Solvalla </strong>(först start 18.15) och <strong>Åby</strong> (start 18.27) och huvudspelets kupong innehåller förutom S:t Leger bland annat Amatörpokalen på Solvalla för B- och K-licensierade körsvenner – och två segermaskiner i ett spännande möte.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/08/skarmavbild20250829kl.08.51.58.jpg" alt="" class="wp-image-761086"/><figcaption class="wp-element-caption">Tiffany Wistrand och Emporio Broline i samband med köpet ifjol. Foto: privat</figcaption></figure>



<p>Tiffany Wistrands treåriga ämne <strong>Emporio Broline</strong> (e. Power) inledde med fyra raka segrar innan han testade tuffare motstånd i Kriterieconsolation och slutade trea. Efter ny seger efteråt blev det en fjärdeplats i rikstotodebuten efter avancemang till dödens från tillägg.</p>



<p>Nu sitter säkre amatörkusken Patrik Fernlund i vagnen. Fernlund har vunnit 14 av 46 starter som kusk under 2025 och från spår tre är segerchansen god i amatörloppet.</p>



<p>Men det finns en likaledes segervan utmanare. Kim Hagoort har kört tre lopp på svensk mark, vunnit två och tagit ett tredjepris. Nu sitter hon upp bakom <strong>Nebraska Lobell </strong>(e. Love You), som segrat i tolv av 20 starter.</p>



<p>––> Travexperternas bästa spik och vassa skrälldrag till V86 publiceras som vanligt klockan 12.00 idag.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/turel.a.heat-617x333.jpg" alt="" class="wp-image-777388"/><figcaption class="wp-element-caption">Maria Törnqvist-tränade Ture L.A. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">3 Både Solvalla och Åby bjuder på godbitar utanför V86-kupongen. På Åby: <strong>Ture L.A.</strong> (e. Maharajah) rusade upp i högsta klassen i vintras och våras efter seger i silverdivisionsfinal och i försök till Paralympiatravet. Efter uppehåll var han tillbaka på banan för fem veckor sedan som tvåa i Hallandsmästaren.</p>



<p>– Han var fullt godkänd som tvåa i sin comeback för några veckor sedan. Nu har han lopp i kroppen och han känns fin i träningen, så jag räknar med en bra insats här. Han har förvisso spår sex bakom bilen, men kan öppna riktigt vasst, så plan A är att hitta till spets och sedan köra där. Uppgifter ser på papperet mycket bra ut, säger Maria Törnqvist på stallets hemsida.</p>



<p>På Solvalla: Timo Nurmos plockar ut ett av landets bästa ston i forna Oaksvinnaren <strong>Adriatica </strong>(e. Bold Eagle) i ett fyra- och femåringslopp för ston. I höst har Adriatica hittat tillbaka till segerformen från 2023 och nu ligger vägen öppen för tredje segern på de fyra senaste starterna i höst.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/11/12v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/11/12v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 <strong>Super Chapter (</strong>e. Chapter Seven) fick se sig besegrad i Breeders Crown-finalen ($600.000) för treåriga hingstar och valacker i senaste starten mot stallkamraten <strong>Meshuggah </strong>(e. Greenshoe) på Mohawk Raceway.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/meshuggah102525newimagemedia1024px-617x347.jpg" alt="" class="wp-image-785739"/><figcaption class="wp-element-caption">Meshuggah och Scott Zeron håller undan för Super Chapter. Foto: New Image Media</figcaption></figure>



<p>På torsdag möts Marcus Melanders topptreåringar i Matron Stakes ($163.050) på tusenmetersbanan Dover Downs.</p>



<p>I stonas uppgörelse i Matron Stakes ($132.350) är Nancy Takter ensam svensk tränare och hon startar <strong>Highlandstarburst (</strong>e. Father Patrick), vilken närmast kommer från seger på Yonkers Raceway.</p>



<p><strong>Matron Stakes</strong> ($163.050)<br>Treåriga hingstar/valacker.<br><em>1.609 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Meshuggah</strong> (e. Greenshoe) – Scott Zeron</li>



<li><strong>Super Chapter</strong> (e. Chapter Seven) – Dexter Dunn</li>



<li><strong>Durante Hanover</strong> (e. Walner) – David Miller</li>



<li><strong>Cheers Hanover </strong>(e. Bar Hopping) – Tim Tetrick</li>



<li><strong>Frank Leahy </strong>(e. Southwind Frank) – Yannick Gingras</li>



<li><strong>My Degenerate</strong> (e. Muscle Hill) – Andy Miller</li>



<li><strong>Go Dog Go </strong>(e. Greenshoe) – Todd McCarthy</li>



<li><strong>Monserrate</strong> (e. Chapter Seven) – Jason Bartlett</li>
</ol>



<p><strong>Matron Stakes</strong> ($132.350)<br>Treåriga ston.<br><em>1.609 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Highlandstarburst</strong> (e. Father Patrick) – Scott Zeron</li>



<li><strong>Stash Some Cash </strong>(e. Walner) – Dexter Dunn</li>



<li><strong>Martz Seven</strong> (e. Swan For All) – Anthony Morgan</li>



<li><strong>Monalishi </strong>(e. Green Manalishi) – Yannick Gingras</li>



<li><strong>Conversano</strong> (e. Muscle Hill) – Andrew McCarthy</li>



<li><strong>My Debt Collecter</strong> (e. Chapter Seven) – Tyler Buter</li>



<li><strong>R Lady W </strong>(e. Walner) – Matt Kakaley</li>



<li><strong>R Dutchess</strong> (e. Father Patrick) – Tim Tetrick</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/burkegingrassep131-617x617.jpg" alt="" class="wp-image-767330"/><figcaption class="wp-element-caption">Ron Burke och Yannick Gingras har tagit många segrar tillsammans. Foto: Mike Lizzi</figcaption></figure>



<p class="has-drop-cap">5 Sulkysport berättade tidigare i veckan berättat om Ron Burkes <a href="https://sulkysport.se/svenskt-direkt-i-paris/" data-type="link" data-id="https://sulkysport.se/svenskt-direkt-i-paris/" target="_blank" rel="noreferrer noopener">rekordresultat</a> som tränare. Nu kan vi också lägga till att han tagit sin 1.000:e seger som tränare i år och det är sjätte gången som han når den milstolpen i sin karriären.</p>



<p>Första gången var 2013 och rekordet när det gäller segrar för en säsong är 2023 med 1.156 vinster.</p>



<h2 class="wp-block-heading">Ron Burkes bästa år:</h2>



<p><strong>År – Segrar</strong></p>



<ul class="wp-block-list">
<li>2023 – 1.156</li>



<li>2014 – 1.093</li>



<li>2013 – 1.090</li>



<li>2022 &#8211; 1.031</li>



<li>2018 – 1.012</li>



<li>2025 – 1.003</li>
</ul>



<p><strong>Fotnot:</strong> resultaten gäller per den 11 november.</p>



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



<p class="has-drop-cap">6 Vincennes har haft tävlingsfritt för andra dagen i rad och för svensk del vänds blickarna mot <strong>Bordeaux </strong>(första start kl. 12.35) och dit åker både Conrad Lugauer och Maria Törnqvist med varsin häst.</p>



<p>I Grand Prix Dynavena (€39.000) ställs <strong>Leroy Boko</strong> (e. Trixton) och <strong>Fighter Simoni</strong> (e. Orlando Vici) mot varandra över 2.650 meter. Etienne Clozier tar hand om Lugauers Leroy Boko, medan Alexis Collette gästspelar bakom Fighter Simoni.</p>



<p><a href="https://www.letrot.com/courses/programme/2025-11-12/3302" data-type="link" data-id="https://www.letrot.com/courses/programme/2025-11-12/3302" target="_blank" rel="noreferrer noopener">Här hittar du startlistorna till tävlingarna i Bordeaux.</a></p>



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



<p class="has-drop-cap">7 Under rubriken ”Beklagligt brott mot sekretessen” skriver Dansk Hestevaeddelöbs verkställande direktör Pål M Tung på <a href="https://www.danskhv.dk/nyheder/aergerligt-brud-paa-fortrolighed/" data-type="link" data-id="https://www.danskhv.dk/nyheder/aergerligt-brud-paa-fortrolighed/" target="_blank" rel="noreferrer noopener">danskhv.dk</a>, att han får kännedom om att konfidentiell information om en viktig del av förhandlingarna med Svensk Travsport har spridits.</p>



<p>”<em>Det är djupt beklagligt att denna information har läckt ut innan alla berörda parter och intressenter har informerats på ett fullständigt och korrekt sätt.</em></p>



<p><em>I förhandlingarnas intresse, som fortfarande är konfidentiella, uppmanar vi alla att invänta det officiella meddelandet, som kommer att publiceras på fredag. Där kommer bakgrunden, sammanhanget och framtidsutsikterna att förklaras.</em></p>



<p><em>Vårt mål är att skapa en starkare och mer hållbar grund för dansk hästsport – där alla aktörer, från travbanor till tränare, ägare och spelare, kan fortsätta att se sig själva som en del av helheten. Detta mål har alltid varit grunden för vårt arbete.”</em></p>



<p>Direktören Pål M. Tung skriver dock inget i sitt uttalande om att danska travförbundet och Svensk Travsport har förhandlat över Charlottenlunds legala ägare Det Danske Travselskabs huvud….</p>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="U8Idrwzi6g"><a href="https://sulkysport.se/kronika/ett-fulspel-utan-dess-like/">Ett fulspel utan dess like</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Ett fulspel utan dess like” &ndash; Sulkysport" src="https://sulkysport.se/kronika/ett-fulspel-utan-dess-like/embed/#?secret=sef9aTShMl#?secret=U8Idrwzi6g" data-secret="U8Idrwzi6g" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
