
<p class="has-drop-cap">1 Årstiden är inne då hästarna börjar komma ned på de allra snabbaste tiderna i loppen, vilket vi fick bevis för på Rivieran igår, då <strong>Iguski Sautonne</strong> (e. Village Mystic) travade 1.08,6a/1.609 meter vid segern i Criterium de Vitesse.</p>



<p>För snart elva år sedan lufsade <strong>Delicious U.S. </strong>(e. Cantab Hall) samma tid över 1.640 meter, en augustikväll i Bollnäs och det har visat sig vara ganska svårt att komma under den tidsnoteringen i just Europa.</p>



<p><strong>Sulkysport listar här de hästar som vunnit på 1.08,6 eller snabbare.</strong><br>Häst Kön/ålder  Far-Mor  Morfar – Bana – År – Tid</p>



<ul class="wp-block-list">
<li><strong>Delicious</strong> s 6 år e.Cantab Hall-Ipsara L.B. e. Lemon Dra – Bollnäs – 2015 – 1.08,6</li>



<li><strong>Vivid Wise As</strong> h 5 år e. Yankee Glide -Temple Blue Chip e. Cantab Hall – Cagnes – 2019 – 1.08,6</li>



<li><strong>Always Ek</strong> h 8 år e. Filipp Roc-Nike Ek e. Varenne – Solvalla – 2024 – 1.08,6</li>



<li><strong>Go On Boy</strong> h 9 år e. Password-Balginette e. Hasting – Enghien – 2025 – 1.08,6</li>



<li><strong>Iguski Sautonne </strong>h 8 år e. Village Mystic-Sara Sautonne e. Juliano Star – Cagnes –  2026 – 1.08,6</li>



<li><strong>Oscar L.A.</strong> h 9 år e. Ready Cash-Esperance e. Abano As – Tingsryd – 2025 – 1.08,5</li>



<li><strong>Gio Cash</strong> h 6 år e. Victor Gio-Give Me Love D.E. e. Judge Joe – Årjäng – 2025 – 1.08,5</li>



<li><strong>Bold Eagle</strong> h 6 år e. Ready Cash-Reethi Rah Jet e. Love You – Solvalla – 2017 – 1.08,4</li>



<li><strong>Go On Boy</strong> h 9 år e. Password-Balginette e. Hasting – Solvalla – 2025 – 1.08,4</li>



<li><strong>Hierro Boko</strong> v 9 år e. From Above-Staro Almighty e. Yankee Glide – Mikkeli – 2023 1.08,3</li>



<li><strong>Ringostarr Treb</strong>** h 7 år e. Classic Photo-Farsalo Egral e. Supergill – Jägersro – 2017 – 1.08,2</li>



<li><strong>Propulsion</strong> h 6 år e. Muscle Hill-Danae e. Andover Hall – Jägersro – 2017 – 1.08,1</li>



<li><strong>Vernissage Grif</strong> h 10 år e. Varenne-Dalia Grif e. Park Avenue Joe – Cagnes – 2024 –  1.08,1</li>



<li><strong>Horsy Dream</strong> h 7 år e. Scipion du Goutier-Bonanza du Closet e. Prince Gede – Solvalla – 2024 – 1.08,0</li>
</ul>



<p>** Ringostarr Treb slutade tvåa i mål bakom Propulsion, som i efterhand diskvalificerades.</p>



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



<p class="has-drop-cap">2 Elitloppet är tolv veckor bort och snart kommer vi att få veta vem eller vilka som blir de första, tidiga inbjudningarna till Solvallas stora sprinterlopp den 31 maj. Det finns några givna hästar som alldeles säkert kommer att säkra sina respektive platser inom de kommande veckorna och det vore väl ingen överraskning om titelförsvararen <strong>Go On Boy</strong> (e. Password) blir först ut.</p>



<p>Romain Derieuxs tioåring gjorde en stark insats som trea i gårdagens Criterium de Vitesse och känner vi tränare Derieux rätt så har han sin häst i absolut toppskick sista söndagen i maj.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/idaodetillard-617x333.jpg" alt="" class="wp-image-824141"/><figcaption class="wp-element-caption">Idao de Tillard och Clement Duvaldestin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>De franska bidragen skulle i princip kunna bli hur många som helst i årets Elitlopp och faktum är att oddssättarna i nuläget tror på fransk seger i loppet även 2026. Thierry Duvaldestins <strong>Idao de Tillard</strong> (e. Severino) är favorit att ta hem Elitloppet i år, trots att hästen varit ifrån tävlingsbanan sedan i höstas, då han tvingades till bukoperation efter ett allvarligt kolikanfall.</p>



<p>En favorit i fara? Minst sagt. Att resa långt med en buköppnad häst som alltså visat tecken på att vara känslig för kolik är kanske inget Duvaldestin-lägret direkt siktar på, dessutom är det ganska tufft att kräva av en opererad häst att hitta tillbaka till samma höga nivå som tävlingshäst, så snart inpå sjukdomsfallet. </p>



<p>Gårdagens segerhäst <strong>Iguski Sautonne</strong> (e. Village Mystic) vore förstås en attraktion på Solvalla. En svart snygging som ser ut att behärska det mesta på en travbana förgyller alltid en söndag på &#8221;Valla&#8221; och Matthieu Abrivard längtar alldeles säkert efter att lyckats vinna något av Europas allra största lopp. Som kusk har han segrat i både Prix de France (Vivid Wise As 2022) och Prix de Paris (Private Love 2010), men i Prix d&#8217;Amérique saknar han seger och i Elitloppet har han som bäst slutat fyra, med <strong>Nimrod Borealis</strong> (e. Arnaqueur) 2009. </p>



<p>Abrivard har även kört egentränade <strong>Gaspar de Brion</strong> (e. Singalo) i Elitloppet och nu har han en häst som kan vara med och hugga på allvar om segern i Iguski Sautonne.</p>



<h2 class="wp-block-heading">De 20 mest betrodda hästarna i Elitloppet 2026<br>Odds enligt ATG</h2>



<p><em>Häst – Odds</em></p>



<ul class="wp-block-list">
<li>Idao de Tillard – 4,50</li>



<li>Don Fanucci Zet – 8,00</li>



<li>Inexess Bleu – 8,50</li>



<li>Allegiant – 9,50</li>



<li>Go On Boy – 11,00</li>



<li>Iguski Sautonne – 11,00</li>



<li>Borups Victory – 14,00</li>



<li>Josh Power – 14,00</li>



<li>Jabalpur – 16,00</li>



<li>Dream Mine – 18,00</li>



<li>A Fair Day – 20,00</li>



<li>Double Deceiver – 20,00</li>



<li>Francesco Zet – 20,00</li>



<li>Frank Gio – 20,00</li>



<li>Gio Cash – 25,00</li>



<li>Jobspost – 25,00</li>



<li>Keep Asking – 25,00</li>



<li>Free Time Jepson – 30,00</li>



<li>Cobra Killer Gar – 35,00</li>



<li>Hokkaido Jiel – 35,00</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/00265355079scoopdyga-617x411.jpg" alt="" class="wp-image-734284"/><figcaption class="wp-element-caption">Jabalpur och Gabriele Gelormini vid en tidigare seger. Foto: Scoopdyga</figcaption></figure>



<p class="has-drop-cap">3 På tal om en av hästarna i listan ovanför. Alain Chavatte-tränade <strong>Jabalpur</strong> (e. Booster Winner), som ifjol vann  Prix Rene Balliere (€200.000) på 1.08,7a/2.100 meter och följde upp med vinster i Grand Prix du Departement des Alpes Maritimes (€180.000) och  Gran Premio delle Nazioni (€200.000), har inte startat sedan han provade lyckan i Prix de Bourgogne i mellandagarna, men nu verkar han vara på gång igen.</p>



<p>På onsdag körs Grand Prix Departemental de la Mayenne (€53.000) i Laval och Alain Chavatte verkar veva igång sin sjuåring lite lagom lugnt. Jabalpur står 50 meter bakom startvoltens hästar och Chavatte har skickat in en illröd gubbe i samband med anmälan. Han tror alltså inte på någon segerchans, men bara det faktum att hästen närmar sig start är lovande inför kommande storloppssäsong i Europa.</p>



<p>Jabalpur får sällskap av bland andra <strong>Ino du Lupin</strong> (e. Scipion du Goutier) och <strong>J&#8217;Aime le Foot</strong> (e. Boccador de Simm) från samma startvolt, medan hästar som <strong>Ksar</strong> (e. Follow You) och <strong>Rikita Jp</strong> (e. Mister J.P.) står 25 respektive 50 meter före Jabalpur och gänget.</p>



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



<p class="has-drop-cap">4 Svensk Travsport presenterade en satsning på fyraåriga ston inför 2026, där 54 lopp har blivit 60 och förstapriset höjts till 60.000 kronor i loppen. Ikväll – på dagens enda svenska bana <strong>Axevalla</strong> (första start 18.20) – är det dags för ett av dessa lopp, men intresset är svalt. Blott sex hästar tävlar om det höjda förstapriset.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/10/skarmavbild20251017kl.10.26.30-617x311.jpg" alt="" class="wp-image-782425" style="aspect-ratio:1.9840300610615311;width:550px;height:auto"/><figcaption class="wp-element-caption">Felicia Hall vid en av segrarna i höstas.<br>Skärmbild ATG-live.</figcaption></figure>



<p>En av dem är hemmatränaren Emilia Leos <strong>Felicia Hall </strong>(e. Googoo Gaagaa), som vann tre lopp förra året och närmast kommer från femteplatsen i en avdelning av Margaretas Tidiga Unghästserie.</p>



<p>– Hon gjorde det jättebra som femma efter att ha dragit tåget i tredjespår. Hon var för övrigt på linje med trean och fyran i mål. Efter det fick hon en hovböld, som stoppade upp henne lite, men det ska inte vara någon fara med formen. Hon duger gott i den här typen av lopp, säger Emilia Leo i Axevallas banprogram.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/03/09v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till måndagens tävlingar.</a></p>



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



<p class="has-drop-cap">5 Han vann både norska Kriteriet 2024 och norska Derbyt 2025, men i årsdebuten mot äldre hästar på Forus i lördags blev det ingen seger. Kjetil Djöseland-tränade <strong>Gigant Tider</strong> (e. Norheim Svenn) fick nöja sig med tredjepriset.</p>



<p><strong>Ådne Odin</strong> (e. Bork Odin) flög förbi i starten när Gigant Tider hade innerspår bakom bilen, men Djöseland tog sig per omgående ut i andraspår och satt i ledning på första långsidan. </p>



<p>Det såg länge bra ut för ledaren, men 300 meter från mål fick Ådne Odin luckan från vinnarhålet och tillsammans med Svein Ove Wassberg spurtade han till lätt seger. Gigant Tider fick även släppa gott spurtande <strong>Tordenskjold</strong> (e. Will Prinsen) förbi sig sista biten.</p>



<p>13-årige Ådne Odin tog seger 37 på 152 försök när han noterade 1.22,4a/2.040 meter och inkasserade 80.000 kronor.</p>



<p>Ådne Odin har varit med i numera nedlagda speedrace för kallblod på Elitloppsfredagen på Solvalla tre gånger och vann vid första försöket 2021. Både 2022 och 2024 slutade han trea.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/eggengunnar-617x333.jpg" alt="" class="wp-image-648131"/><figcaption class="wp-element-caption">Gunnar Eggen. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">6 <strong>Gunnar Eggen</strong>, en av norsk travsport allra största travtränare, gick bort den 10 oktober 2024 och Bjerke hedrar honom med ett äres- minneslopp sedan våren samma år. Eggen började jobba för stortränaren Karsten Buer på Bjerke 1968 efter att ha börjat sin travkarriär på Jarlsberg Travbana något år tidigare.</p>



<p>1973 plockades den egna licensen ut och Bjerke blev Gunnar Eggens hemmabana, där han bokförde sig för 20 banchampionat, det första kom 1981. <br>13 gånger blev Eggen norsk champion och 1996 lade han beslag på titeln som Europas bästa kusk. Hans karriär var magnifik och han hann vinna 5.546 sulkylopp innan karriären var över.</p>



<p>Största segern av alla dessa borde vara den i March Of Dimes ($600.000) på Garden State Park i november 1988 med <strong>Sugarcane Hanover</strong>, där Eggen, efter en väl avvägd styrning, avväpnade de båda giganterna <strong>Mack Lobell </strong>och <strong>Ourasi</strong> sista biten innan mål. Loppet direktsändes i TV3 och Hans Petter Tholfsen, en annan gigant i norsk travsport, satt med i tv-studion som expertkommentator när det blev norsk seger när &#8221;tidernas travlopp&#8221; avgjordes.</p>



<p>På lördag körs Gunnar Eggens Minneslopp och det är för guldhästar loppet är utskrivet. Från svenskt håll gör Daniel Wäjerstens <strong>Mellby Jinx</strong> (e. Ready Cash) intressant årsdebut från spår åtta bakom bilen. Åttaåringen har inte startat sedan tredjeplatsen i finalen av UET Elite Circuit på Solvalla i oktober och hela 2025 blev ytterst lyckat för Mellby Gårds valack. Mellby Jinx tjänade drygt 4,3 miljoner kronor på sina tolv årsstarter.</p>



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



<p class="has-drop-cap">7 Travsporten i USA lever i många meningar med hot om nedskärningar, minskade resurser i form av prispengar och – kasinon. Kasinon på banorna har visat sig vara en lukrativ business för hästfolket då stora pengar från &#8221;racinos&#8221; hamnar i sportens händer.</p>



<p>Indiana är staten där sulkysporten blomstrat de senaste 10-15 åren. Fyllda startfält i loppen, större spelutbud därmed, har gjort Indiana till en intressant stat att hålla till i om man gillar travhästar eller passgångare, plus att banan <strong>Hoosier Park </strong>har uppgraderats till något av en storbana tack vare de ökade prismedlen. Unghästloppen <strong>Peter Haughton Memorial </strong>och <strong>Jim Doherty Memorial </strong>körs som bekant i Indiana numera och banan är med och hugger om att få arrangera <strong>Hambletonian</strong> med början 2027.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260220kl.07.04.21-617x330.jpg" alt="" class="wp-image-821192"/><figcaption class="wp-element-caption">Hoosier Park hotas av nya kasinon i regionen.</figcaption></figure>



<p>Men nu hotas hästsporten i Indiana av ytterligare kasinon, via ett lagförslag som statens guvernör Mike Braun undertecknat. Braun menar dock att beslutet om att öppna statens 14:e kasino inte är upp till honom eller någon annan i generalförsamlingen, utan att en folkomröstning ska genomföras innan ett genomklubbande sker i frågan. Lagstiftningen gör det möjligt att utfärda en 14:e kasinolicens i den nordöstra delen av delstaten Indiana och skulle kunna påverka racino<strong>&#8211;</strong>anläggningarna vid Harrah’s Hoosier Park och Horseshoe Indianapolis.</p>



<p>Enligt en studie från september 2025, framtagen för <strong>Indiana Gaming Commission</strong> av Spectrum Gaming Group, beräknas ett kasino i den nordöstra delen av delstaten leda till en årlig minskning av de justerade bruttointäkterna på 14,67 miljoner dollar för de befintliga spelanläggningarna.</p>



<p>Av detta beräknas <strong>1,76 miljoner dollar per år</strong> vara en minskning av bruttointäkterna vid <strong>Harrah’s Hoosier Park</strong> och <strong>Horseshoe Indianapolis</strong>, något som skulle påverka både verksamheten och prispengarna inom trav-, galopp- och quarterhorse-tävlingar negativt. Men det påpekas också att siffrorna kan vara alldeles för låga; att större intäktsminskningar än de nyss nämnda kan bli ett faktum.</p>



<p>Skulle folkomröstningen i de tre berörda länen i nordöstra Indiana ge negativt utslag, uppfattas det som positivt för hästsporten och nya eventuella försök att placera ut kasinon i regionen kräver ny lagstiftning och kan tidigast ske 2027.</p>
