
<p class="has-drop-cap">1 Tjugoen travare, tio år och äldre, har vunnit på 1.09-tider.<br>Av de tvåsiffriga 1.09-travarna toppar elvaårige <strong>Commander Crowe</strong> med 1.09,0 före <strong>Timoko</strong>, vilken noterade samma tid som tioåring. Snabbaste tiden bland tolvåringarna delas mellan <strong>Spice It Up Lindy </strong>och <strong>Tycoon Conway Hall</strong> med 1.09,7.</p>



<p>Av de äldre stona toppar tioåriga <strong>Billie de Montfort</strong>, villken noterade 1.09,5 på Solvalla 2021. En ”gamling” har travat under 1.10,0 på medeldistans. <strong>Delia du Pommereux</strong> vann på 1.09,8a/2.100 meter på Vincennes i år.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/billiedemontfort1-617x333.jpg" alt="" class="wp-image-169836"/><figcaption class="wp-element-caption">Billie de Montfort (1) vid en seger på Solvalla. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Tio av 1.09-tiderna har noterats i Europa, varav sju i Sverige – övriga har skett på amerikansk mark.</p>



<p>Nedan hittar ni Sulkysports unika lista över de snabbaste äldre vinnarna (tio år och uppåt) per den 21 juni 2023.</p>



<h2 class="wp-block-heading">Tolv år:</h2>



<p><strong>Namn (kön/far) – Bana – År – Vinnartid</strong></p>



<ul class="wp-block-list">
<li><strong>Spice It Up Lindy</strong> (v e. S.J.’s Caviar) – Vernon Downs – 2015 – 1.09,7</li>



<li><strong>Tycoon Conway Hall</strong> (h e. Conway Hall) – Tingsryd – 2022 – 1.09,7</li>
</ul>



<h2 class="wp-block-heading">Elva år:</h2>



<ul class="wp-block-list">
<li><strong>Commander Crowe</strong> (v e. Juliano Star) – Meadowlands – 2014 – 1.09,0</li>



<li><strong>Jl Cruze </strong>(v e. Crazed) – Meadowlands – 2022 – 1.09,6</li>



<li><strong>Jl Cruze</strong> (v e. Crazed) – Chester – 2022 – 1.09,6</li>



<li><strong>Food Money</strong> (v e. Andover Hall) – Tingsryd – 2019 – 1.09,8</li>
</ul>



<h2 class="wp-block-heading">Tio år:</h2>



<ul class="wp-block-list">
<li><strong>Timoko</strong> (h e. Iomoko) – Solvalla – 2017 – 1.09,0</li>



<li><strong>Timoko</strong> (h e. Imoko) – Cagnes-sur-Mer – 2017 – 1.09,1</li>



<li><strong>Obrigado</strong> (v e. Boy Band) – Meadowlands – 2020 1:51,2 1.09,2</li>



<li><strong>Timoko</strong> ( h e. Imoko) – Cagnes-sur-Mer – 2017 – 1.09,5</li>



<li><strong>Billie de Montfort </strong>(s e. Jasmin de Flore) – Solvalla – 2021 – 1.09,5</li>



<li><strong>Ranch Kelly</strong> (s e. Tsar d’Inverne) – Mikkeli – 2018 – 1.09,7</li>



<li><strong>Up and Quick</strong> (h e. Buvetier d’Aunou) – Jägersro – 2018 – 1.09,7</li>



<li><strong>Queer Fish</strong> (v e. Varenne) – Solvalla – 2019 – 1.09,7</li>



<li><strong>Coktail Fortuna</strong> (v e. Love You) – Eskilstuna – 2019 – 1.09,8</li>



<li><strong>Delia du Pommereux</strong> (s e. Niky) – Vincennes – 2023 – 1.09,8*</li>



<li><strong>Arch Madness</strong> (v e. Balanced Image) – Chester – 2014 – 1.09,9</li>



<li><strong>Very Very Fast</strong> (v e. Quaro) – Pocono Downs – 2019 – 1.09,9</li>



<li><strong>Final Breath </strong>(v e. Victory Sam) – Meadows – 2020 – 1.09,9</li>



<li><strong>Jl Cruze</strong> (v e. Crazed) – Meadowlands – 2021 – 1.09,9</li>



<li><strong>Crazycat</strong> (v e. Crazed) – Pocono Downs – 2023 – 1.09,9</li>
</ul>



<p><strong>Fotnot: *</strong>tiden satt över medeldistans.</p>



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



<p class="has-drop-cap">2 Midnattstravet på<strong> Dannero</strong> är en mångårig tradition och ikväll med första start kl 20.00 är det dags för årets folkfest, där sista loppet går i mål strax före midnatt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/egoboyheat-617x534.jpg" alt="" class="wp-image-413864"/><figcaption class="wp-element-caption">Ego Boy besökte Dannero. Foto Stalltz.se Ego Boy och Ingemar Olofsson</figcaption></figure>



<p>Mannen bakom midnattstravet var Danneros store man, eldsjäl och mångårige ordförande Josef Bodin. Han var med från början i styrelsen när Ådalens Travsällskap bildades 1957 och lockade folk till banan med både hästar och jippon. ”Kändislopp och popsångare stod ofta på menyn”, skriver Dannero i programmet till kvällens tävlingar. På den fyrbenta sidan lockades både <strong>Ego Boy</strong> och <strong>Legolas</strong> (med flygplan!) till Ådalens pärla.</p>



<p>Den mest bestående idén från Josef Bodin är annars just midnattstravet – och det var en ren protestreaktion från Bodins sida. Han var allt annat än nöjd när Dannero tilldelades en tävlingsdag vid den tidpunkten för 61 år sedan – i skördetider i jordbruket och Bodins svar var:</p>



<p><strong><em>”Vi kör på natten!”</em></strong></p>



<p>Midnattstravet var fött och ikväll avgörs Midnattspokalen – Göta och Josef Bodins Minne – för högsta klassen med <strong>Global Badman</strong> (e. Yield Boko) mot bland andra <strong>Tjacko Zaz</strong>, som debuterar i Oskar J Anderssons regi.</p>



<p>Det högst doterade loppet är finalen av High Coast Race – 125.000 kronor till vinnaren – över sprinterdistans, där åtta hästar vardera sluter upp i två försök. Daniel Redéns Sprintermästarfinalist från 2021, <strong>Epimetheus</strong> (e. Hard Livin), dyker upp i ena försöket, medan Oskar J Andersson startar <strong>One Kind of Art </strong>(e. One Too Many), som är tillbaka på svensk mark efter en vinter i Frankrike.</p>



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



<p class="has-drop-cap">3 Rättviks stora tävlingsdag runt midsommar kommer på lördag med Breeders Crown-försök, men ikväll (första start 18.30) värmer dalabanan upp med försök- och finalloppet Hästägarcupen som toppnummer. Hästar i två klasser gör upp om sju finalplatser i vardera försök över sprinterdistans och möts från dubbla volter i finalen med 60.000 kronor till vinnaren.</p>



<p>Fredrik Palm-tränade <strong>High On Life Vixi </strong>(e. Quite Easy) och Susanne Richters <strong>Billy Idol</strong> (e. Top Billing) tillhör favoritskaran i vardera avdelning. Av de tio senaste årens finalvinnare har sju startat från 2.140 meter, medan tre inlett med 20 meters tillägg.</p>



<p><strong>Mantorp</strong> (första start 12.20) är först ut och där ställs David Perssons finalist från Drottningpokalen, <strong>Donna Summer </strong>(e. Ready Cash) mot två kapabla hästar som har sina respektive debuter i ny regi avklarade. Det handlar om <strong>Sidney Celeber</strong> (e. Readly Express), som bytt Roger Walmann mot Preben Sövik, och <strong>Daven Port </strong>(e. Cantab Hall), som kommit i till Per Lennartsson från Timo Nurmos och Mattias Djuse.</p>



<p>Det handlar om ett lopp för hästar med högst 950.000 kronor på kontot och 25.000 kronor i förstapris.</p>



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



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



<p class="has-drop-cap">4 I natt svensk tid drar tvååringstävlandet igång på allvar i USA. På Yonkers Raceway hålls två försök i New York Sire Stakes ($77.300) för hingstar/valacker. Fem svensktränade travare finns på plats och i det <a rel="noreferrer noopener" href="https://racing.ustrotting.com/goto.aspx?target=12,90049" target="_blank">första försöket</a> startar Marcus Melander <strong>Wild Ticket </strong>(e. Chapter Seven), Åke Svanstedt <strong>Mister Mellby </strong>(e. Chapter Seven) och Nancy Takter <strong>Bargain</strong> (e. Chapter Seven).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/077wildticketupp221001adamstromstalltz-617x439.jpg" alt="" class="wp-image-362928"/><figcaption class="wp-element-caption">Wild Ticket. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>Wild Ticket kostade 200.000 dollar i Lexington förra året, medan Bargain gick loss för 30.000 dollar på samma auktion. Mister Mellby är både uppfödd och ägd av Rune ”Mellby Gård” Andersson.</p>



<p>I det <a rel="noreferrer noopener" href="https://racing.ustrotting.com/goto.aspx?target=12,90050" target="_blank">andra försöket</a> plockar också Marcus Melander och Åke Svanstedt ut varsin häst. Störst intresse drar <strong>Thinker Monkey</strong> (e. Chapter Seven) till sig. Helbrodern till trefaldige Breeders Crown-vinnaren G<strong>impanzee</strong>, 1.08,4<em>/</em>$2.792.478, <strong>Iteration</strong>, 1.09,1/$780.818, och <strong>Mandrill,</strong> 1.11,5/$32.500, vann sitt kval på 1.15,1. Han såldes i Lexington förra året för 500.000 dollar.</p>



<p>Kvalvann gjorde också Åke Svanstedts <strong>Situationship</strong> (e. Chapter Seven) på 1.15,1. Situationship, som delägs av bland andra Knutsson Trotting och Tomas Andersson i Nossebro, kostade 80.000 dollar i Lexington.</p>



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



<p class="has-drop-cap">5 Vilken tillgång till djursjukvård ska vi ha i Sverige? Är akutvård dygnet runt i hela landet inte längre möjligt? Eller kommer regeringen höja ribban till djurens fördel? Och vem ska då stå för notan?</p>



<p>Ovanstående frågor kommer att diskuteras i Almedalen när Agria bjuder in till ett panelsamtal den 30 juni mellan klockan 10.00-11.00 i spegelsalen på Clarion Hotel i Visby.</p>



<p>Utgångspunkten – skriver Agria i ett pressmeddelande – för samtalet är den statliga utredningen ”Bättre förutsättningar inom djurens hälso- och sjukvård.”</p>



<p>För de som inte är i Almedalen kan följa panelsamtalet via <a href="https://www.facebook.com/events/240425052056951/?acontext=%7B%22ref%22%3A%2252%22%2C%22action_history%22%3A%22[%7B%5C%22surface%5C%22%3A%5C%22share_link%5C%22%2C%5C%22mechanism%5C%22%3A%5C%22share_link%5C%22%2C%5C%22extra_data%5C%22%3A%7B%5C%22invite_link_id%5C%22%3A213129168288125%7D%7D]%22%7D" target="_blank" rel="noreferrer noopener">länk</a>.</p>



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



<p class="has-drop-cap">6 Efter den omedelbara succén med seger i debuten på fransk mark jagar idag Jörgen S Eriksson-tränade <strong>G.R.J.’s Wolverine</strong> (e. Yield Boko) en ny triumf under torsdagseftermiddagen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/11/jorgenseriksson-617x333.jpg" alt="" class="wp-image-122834"/><figcaption class="wp-element-caption">Jörgen S Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Denna gång är <strong>Mauquenchy</strong> (första start 12.15) skådeplatsen och återigen är det Jonathan Carré som flygs ner till Frankrike för att rida nioåringen som bland annat möter Pierre Levesques svenskfödde <strong>Huis Clos</strong> (e. Bird Parker) i Prix du Cafe de la Marie Bury (€27.000). Loppet rids över 2.850 meter voltstart och vid mållinjen väntar 12.150 euro på vinnaren.</p>



<p>Även Tomas Malmqvist har starthäst i Mauquenchy då <strong>Key Biscayne (</strong>e. Face Time Bourbon) kommer ut i treåringsloppet Prix Equi-Ressources-IFCE (€23.000) tillsammans med Franck Ouvrie.</p>



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



<p class="has-drop-cap">7 Rebecca Dahlén och Dennis Palmqvists <strong>Idabel Celeber</strong> (e. Gentle Star-Amanda Celeber), 1.14,9am/274.500 kr, har blivit mor till en hingst efter Calgary Games och det är hennes sjätte avkomma. Av de startande hästarna har <strong>Likeaboss </strong>(e. Brad de Veluwe), 1.12,7am*/628.400 kr, gjort bäst ifrån sig och han vann tio lopp på 20 starter.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/skarmavbild20230621kl.10.33.10-350x283.jpg" alt="" class="wp-image-460813"/><figcaption class="wp-element-caption">Idabel Celeber med sin hingst efter Calgary Games. Foto: privat</figcaption></figure>



<p>Idabel Celeber ingår i samma syskonskara som storstjärnan <strong>Tamla Celeber</strong> (e. Cantab Hall), 1.10,2ak/8.310.666 kr, <strong>Odessa Celeber</strong> (e. Cantab Hall), 1.11,2ak/1.130.180 kr, och <strong>Sidney Celeber</strong> (e. Readly Express), 1.11,5ak/947.000 kr.</p>



<p>Trefaldiga världsrekordhållaren <strong>Delicious U.S. </strong>(e. Cantab Hall-Ipsara L.B.), 1.08,6ak*/6.581.572 kr, har fått sin andra avkomma. Tidigare i veckan nedkom hon med en hingst efter Hard Livin. Hennes förstfödde <strong>Heavenly Zet </strong>(e. Daley Lovin) kvalade på 1.17,6/2.140 meter och med ett slutvarv på 1.12,1 den 17 maj på Solvalla. På lördag debuterar treåringen i Rättvik.</p>



<p>Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
