
<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 13 fyraåringar på tre volter gör upp om segern. De tyngsta meriterna har<strong> Stens Rubin</strong> (e. Readly Express), som vann Breeders Crown förra året och slutade tvåa i Sprintermästaren i somras, plus <strong>Global Etalon</strong> (e. Brillantissime), som slutade trea i Svenskt Travderby.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/globaletalonmadm240820adamstromstalltz-617x399.jpg" alt="" class="wp-image-624188"/><figcaption class="wp-element-caption">Global Etalon håller undan för Herakles Zet i försöket till Svenskt Travderby. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Även Stens Rubin var med i Derbyt och det gäller även <strong>Underground Artist </strong>(e. Royalty For Life) av kvällens S:t Leger-hästar. Robert Bergh är tillbaka efter 20 dagar i utvisningsbåset – sju segrar på 17 starter har stallet räknat in under perioden – och hemmatränaren sitter upp bakom Underground Artist, som är en av tre hästar från Bergh-stallet i S:t Leger.</p>



<p>Han har firat stora framgångar i loppet de senaste åren och vunnit tre av de fem senaste upplagorna. Hans stjärna <strong>Power</strong> (e. Googoo Gaagaa) har löpningsrekordet med 1.13,8/3.180 meter från 2020. Svenska rekordet för fyraåriga svenska hingstar och valacker är två tiondelar vassare och innehas av <strong>High On Pepper</strong> (e. Ready Cash). Den rekordtiden tangerade <strong>Hustle Rain</strong> (e. Raja Mirchi) när han tog hem S:t Leger förra året.</p>



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



<p>År, häst (far) – Kusk (tränare) – Segertid/distans</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>
</ul>



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



<p class="has-drop-cap">2 <strong>Åby</strong> (första start 18.27) delar kvällens expresstrav med <strong>Solvalla</strong> (start 18.15) och på V86-spelet väntar en saftig dubbeljackpot ikväll. Nästan tio miljoner kronor extra ligger i åttarättspotten sedan det varken blivit utdelning på sju eller sex rätt förra veckan.</p>



<p>Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</p>



<p>Hos vår samarbetspartner Travnet finns andelar till kvällens dubbeljackopot på V86 på Högkvarteret – <a href="https://www.atg.se/hogkvarteret/V86_2024-11-13_40_1" data-type="link" data-id="https://www.atg.se/hogkvarteret/V86_2024-11-13_40_1" target="_blank" rel="noreferrer noopener">här är alla andelar!</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/carlhalbakokm210505adamstromstalltz-617x382.jpg" alt="" class="wp-image-159717"/><figcaption class="wp-element-caption">Carl Halbak. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Utanför V86-kupongen väntar en spännande comeback – efter nästan två års tävlingsuppehåll! <strong>Carl Halbak</strong> (e. Orlando Vici) har nämligen inte startat sedan annandagen 2022, då i Mattias Djuses regi där han bland annat vintern 2021 var etta och tvåa i två avdelningar i Margaretas Tidiga Unghästserie och året efter vann han bronsdivisionsförsök och Gunnar Nordins lopp.</p>



<p>I våras gick hästen i träning hos Jörgen S Eriksson och efter att ha tvingats strykas från en tilltänkt start i juli är hästen nu redo för tävlingsbanan igen i ett dubbelklasslopp. </p>



<p>I Solvallaseriens tredje försöksomgång ligger högsta klassen också utanför V86-spelet när Susanne Frang plockar ut <strong>Jongleur</strong> (e. Django Riff), som vunnit på 1.10,6 respektive 1.10,5 i två av sina tre senaste starter med tränarsambon Magnus A Djuse i vagnen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/11/13v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/11/13v86.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">3 Svenska tränare står bakom fem av de sex snabbaste tvååringarna i världen i år. Svenskfödde <strong>Gap Kronos</strong> har sprungit fortast tillsammans med trion <strong>Luna Lovegood</strong>, <strong>Maryland </strong>och <strong>Memento Mori.</strong> Alla fyra har avverkat en engelsk mil på 1.09,5.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/09/gapkronosasm240926adamstromstalltz-617x383.jpg" alt="" class="wp-image-639593"/><figcaption class="wp-element-caption">Svenskfödde Gap Kronos vid seger för Åke Svanstedt. Foto: Adam Ström/stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Snabbaste tvååringarna 2024</h2>



<p><strong>Namn (kön) – Far – Tränare – Vinnartid</strong></p>



<ul class="wp-block-list">
<li><strong>Gap Kronos</strong> (h) – Face Time Bourbon – Åke Svanstedt – 1.09,5</li>



<li><strong>Luna Lovegood </strong>(s) – Gimpanzee – Marcus Melander – 1.09,5</li>



<li><strong>Maryland </strong>(h) – Chapter Seven – Marcus Melander – 1.09,5</li>



<li><strong>Memento Mori</strong> (v) – Chapter Seven – Eric Patalan – 1.09,5</li>



<li><strong>Sound Judgement </strong>(s) – Muscle Hill – Jim Oscarsson – 1.09,6</li>



<li><strong>Super Chapter</strong> (h) – Chapter Seven – Marcus Melander – 1.09,6</li>
</ul>



<p>Att de amerikanska tvååringarna är snabbare än de jämngamla i Europa är ingen nyhet, men vi har både fått uppleva europa- och svenskt rekord under 2024. <strong>Ginostrabliggi </strong>(e. Muscle Hill) vann på 1.11,9 i Milano och i förra veckan i Sverige travade <strong>Eyeofthetiger</strong> (e. Django Riff) 1.12,0a/1.640 meter.</p>



<p>Världsrekordet för tvååriga hingstar/valacker har Åke Svanstedts <strong>Southwind Tyrion </strong>(e. Muscle Hill) med 1.09,1, rekordet för ston har <strong>Mission Brief </strong>(e. Muscle Hill) med 1.08,7 och valackrekordet innehavs av <strong>Memento Mori </strong>(e. Chapter Seven) på 1.09,5. I sammanhanget kan sägas, att Mission Brief satte sitt världsrekord den 2 oktober 2014 och är mer än tio år gammalt. Southwind Tyrion travde sitt rekord 9 oktober 2020 och Memento Mori den 4 oktober i år.</p>



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



<p class="has-drop-cap">4 På lördag bjuder Rom på Gran Premio Tino Triossi (€154.000) och Gran Premio Antonio Carena (€66.000), men inget av Grupp I- eller II-loppet har lyckats samla fulla startfält. Endast sju hästar har definitivanmälts till fyraåringsloppet Gran Premio Tino Triossi över medeldistans och lika många fyraåriga ston finns med i Gran Premio Antonio Carena.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/02/executivek.jpg" alt="" class="wp-image-413984"/><figcaption class="wp-element-caption">Executiv Ek och Alessandro Gocciadoro.</figcaption></figure>



<p>Alessandro Gocciadoro kör favoriterna i båda loppen – <strong>Executiv Ek</strong> och <strong>East Asia</strong> – och enda utländska inslaget är österrikiska Derbyvinnaren <strong>Mona Lisa Venus</strong> i Gran Premio Antonio Carena.</p>



<p><strong>Gran Premio Tino Triossi</strong> (€154.000)<br>Fyraåringar.<br><em>2.100 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Eolo Jet </strong>(e. Wishing Stone) – Antoino Simioli</li>



<li><strong>Ector Francis</strong> (e. Nad al Sheba) – Gaetano di Nardo</li>



<li><strong>Encierro</strong> (e. Tobin Kronos) – Gaspare lo Verde</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Santo Mollo</li>



<li><strong>Extra Model</strong> (e. Rusty Grif) – Roberto Vecchione</li>



<li><strong>Executiv Ek</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Ernesto Spritz </strong>(e. Maharajah) – Andrea Farolfi</li>
</ol>



<p><strong>Gran Premio Antonio Carena</strong> (€66.000)<br>Fyraåriga ston.<br><em>1.640 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>East Asia </strong>(e. Ready Cash) – Alessandro Gocciadoro</li>



<li><strong>Eloida</strong> (e. Napoleon Bar) – Mario Minopoli Jr.</li>



<li><strong>Emma dei Veltri</strong> (e. Maharajah) – Antionio di Nardo</li>



<li><strong>Eridamia </strong>(e. Adrian Chip) – Marco Stefano</li>



<li><strong>Euphoria Bi </strong>(e. Donato Hanover) – Mario Biasuzzi</li>



<li><strong>Mona Lisa Venus</strong> (e. Light Kronos) – Hubert Brandstätter</li>



<li><strong>Eternity Bar</strong> (e. Love You) – Antonio Simioli</li>
</ol>



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



<p class="has-drop-cap">5 Jörgen Westholm-tränade <strong>Santos de Castella </strong>(e. Readly Express) är tillbaka på fransk mark idag efter fyra starter på hemmaplan. Sex starter har utmynnat i två andraplatser som bäst tidigare i trikolorens land.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/7santosdecastella-617x333.jpg" alt="" class="wp-image-358726"/><figcaption class="wp-element-caption">Santos de Castella vid segern i bronsdivisionens final 2022. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Idag tar Benjamin Rochard hand om tömmarna i Prix Jacques Brion (€35.000) över 2.150 meter autostart i Mauquenchy. Bland motståndarna finns Stefan Arvidssons <strong>G.K. Justus </strong>(e. Brad de Veluwe), <strong>Mister Donald </strong>(e. Niky) och svenskägde <strong>Bitcoin d’Arc</strong> (e. Voltigeur de Myrt).</p>



<p>Till Mauquenchy åker också Jarmo Niskanen med en duo. Både <strong>Kiss Wood</strong> (e. Fabulous Wood) och <strong>Kai la Sha</strong> (e. Earl Simon) startar i Prix l’Horizon (€35.000) över 2.850 meter. Fyraårige valacken Koss Wood jagar sin fjärde årsseger, medan Kai la Sha vunnit ett lopp i år.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/mauquenchy-2024-11-13/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/mauquenchy-2024-11-13/" target="_blank" rel="noreferrer noopener">Här är startlistorna </a><a href="https://sulkysport.se/trav-och-galopp/mauquenchy-2024-11-13/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/mauquenchy-2024-11-13/">till tävlingarna i Mauquenchy.</a></p>



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



<p class="has-drop-cap">6 Fyra franska tränare blev bestulna i Montegiorgio i helgen och på flera olika hästrelaterade saker för ett totalt värde av 40.000 euro. Enligt uppgifter fanns det 18 vakter(!) runt banan, men det hjälpte inte…i söndags morse var fyra sulkys och kompletta selar borta för Loris Garcia, Richard Westerink, Benjamin Goetz och Pierrick Le Moel.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/richardwesterink2-617x333.jpg" alt="" class="wp-image-308556"/><figcaption class="wp-element-caption">Richard Westerink. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fransmännen blev först lovade att få ersättning för de stulna sakerna av banan i Montegiorigo, men genom olika kontakter lyckades det nystas upp vilka som låg bakom kuppen och nu ska allt ha återlämnats till sina rättmätiga ägare.</p>



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



<p class="has-drop-cap">7 Stor spännvidd var det mellan priserna på online-auktionen Asta General Trotto igår och allra mest betalades för <strong>Antelope Gar</strong> (e. Varenne-Mind Wise As), 1.12,5/€22.270, dräktig med Muscle Hill.</p>



<p>Klubban föll på 50.500 euro för Antelope Gar, vilken har en startande avkomma sedan tidigare. <strong>Faraone Caraf </strong>(e. Face Time Bourbon) har tagit rekordet 1.13,4 och tjänat 22.270 euro.</p>



<p>Själv är modern undan flerfaldiga Grupp I-vinnaren <strong>Mind Wise As</strong> (e. Lemon Dra), 1.13,4/€323.786. Hon har sin främsta avkomma i <strong>Velvet Gio</strong> (e. Nad al Sheba), 1.10,5/€371.148, som vunnit C.L. Müllers Memorial på Jägersro i regi Magnus Dahlén.</p>



<p><a href="https://www.its-aste.com/aste/asta-generale-trotto-on-line-11-12-novembre-2024/" data-type="link" data-id="https://www.its-aste.com/aste/asta-generale-trotto-on-line-11-12-novembre-2024/" target="_blank" rel="noreferrer noopener">Samtliga resultat från auktionen hittar du här.</a></p>
