
<p class="has-drop-cap">1Tre gånger har han blivit tvåa i Hambletonian Stakes. I år har Marcus Melander fyra chanser: <strong>Blank, Maryland, Meshuggah</strong> och <strong>Super Chapter</strong>. Den sistnämnde har vunnit samtliga starter i år, medan Maryland fortfarande saknar seger under 2025.<br>– Maryland och Super Chapter är två väldigt bra hästar och det vore orättvist att säga att den ena är bättre än den andra. Super Chapter har inte gjort ett enda fel i år, medan Maryland vann allt som han kunde vinna som tvååring, säger Marcus Melander.</p>



<p>Hittills har det blivit 13 svensktränade vinnare i Hambletonian Stakes och sju chanser finns till svensk seger när fältet släppes iväg ikväll klockan 22.47 svensk tid.</p>



<p>Men det är inte bara Marcus Melander som har chans till seger. Åke Svanstedt selar ut duon <strong>Gap Kronos</strong> och <strong>Nordic Catcher</strong>, medan <strong>Maximus Mearas</strong> är Lucas Wallins bidrag.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/08/wb080721r15captaincorey-617x346.jpg" alt="" class="wp-image-196523"/><figcaption class="wp-element-caption">Captain Corey och Åke Svanstedt vid vinsten i Hambletonian Stakes. Foto: Lisa Photo</figcaption></figure>



<p><strong>Svenska vinnare i Hambletonian Stakes:</strong><br><em>År – Häst (far) – Kusk/tränare</em></p>



<ul class="wp-block-list">
<li>1985 <strong>Prakas</strong> (e. Speedy Crown) – Bill O’Donnell/Per Eriksson</li>



<li>1988 <strong>Armbro Goal</strong> (e. Speedy Crown) – John Campbell/Jan Johnson</li>



<li>1991 <strong>Giant Victory</strong> (e. Super Bowl) – Jack Moiseyev/Per Eriksson</li>



<li>1992 <strong>Alf Palema</strong> (e. Speedy Somolli) – Mickey McNichol/Per Eriksson</li>



<li>1997 <strong>Malabar Man</strong> (e. Supergill) – Malvern Burroughs/Jimmy Takter</li>



<li>2001 <strong>Scarlet Knight</strong> (e. Pine Chip) – Stefan Melander/Stefan Melander</li>



<li>2010 <strong>Muscle Massive</strong> (e. Muscles Yankee) – Ron Pierce/Jimmy Takter</li>



<li>2014 <strong>Trixton</strong> (e. Muscle Hill) – Jimmy Takter/Jimmy Takter</li>



<li>2015 <strong>Pinkman</strong> (e. Explosive Matter) – Brian Sears/Jimmy Takter</li>



<li>2017 <strong>Perfect Spirit</strong> (e. Andover Hall) – Åke Svanstedt/Åke Svanstedt</li>



<li>2021 <strong>Captain Corey</strong> (e. Googoo Gaagaa) – Åke Svanstedt/Åke Svanstedt</li>



<li>2023 <strong>Tactical Approach</strong> (e. Tactical Landing) – Scott Zeron/Nancy Takter</li>



<li>2024 <strong>Karl</strong> (e. Tactical Landing) – Yannick Gingras/Nancy Takter</li>
</ul>



<p><a href="https://sulkysport.se/fokus/hast-mot-hast-absolut-bast/" target="_blank" rel="noreferrer noopener">Intervju: Här är Marcus Melanders tankar inför Hambletonian.</a></p>



<p><a href="https://sulkysport.se/skriver-historia-i-100e-upplagan/" target="_blank" rel="noreferrer noopener">Det snackas om: Här är smått &#038; gott om Hambohistorien och årets alla deltagare.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/egoboyelitloppet73-617x333.jpg" alt="" class="wp-image-413868"/><figcaption class="wp-element-caption">Ego Boy segerdefilerar efter Elitloppet 1973 tillsammans med ägarna Berit och Tage Hedberg. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap">2För svensk travsport blev söndagen den 27 maj 1973 den största dagen någonsin på svensk mark. Då besegrade inte bara <strong>Ego Boy</strong> (e. Ego Hanover) amerikanske stortravaren <strong>Flower Child</strong> i skiljeheat i Elitloppet utan travade också 1.13,8 som tvåa i det andra heatet – han vann det första – vilket var det snabbaste tiden i Europa vid den tidpunkten.</p>



<p>Ego Boy segrade även i en rad andra storlopp; Grotje Prijs der Lage Landen, Hugo Åbergs Memorial, Silverhästen, Skandinaviskt Mästerskap, Svenskt Mästerskap och Svenskt Trav S:t Leger.<br>Året efter triumfen på Solvalla insjuknade Ego Boy hastigt och på pingstafton hittades han död i sin box. Totalt sprang Ingemar Olofssons stjärna in 671.030 kronor.</p>



<p>Ego Boy är begravd i vinnarcirkeln på Rättvikstravet och varje år hedras han med Ego Boys Minne. I eftermiddag i Rättvik (första start 14.45) är det dags för årets upplaga.<br>Det brukar gå undan i gulddivisionen över sprinterdistans. Fredrik B Larsson-tränade <strong>Milliondollarrhyme</strong> (e. Ready Cash) är innehavare av löpningsrekordet, då han tog hem 2021 års upplaga på 1.09,5a/1.640 meter.</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/06/jobspostmedm250628adamstromstalltz-617x386.jpg" alt="" class="wp-image-737170"/><figcaption class="wp-element-caption">Jörgen Westholm-tränade segermaskinen Jobspost och Mats E Djuse hade inga större problem att ta hem silverfinalen från dödens. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">3Rättvik bjuder på flera godbitar. Som Jörgen Westholms segermaskin <strong>Jobspost</strong> (e. Readly Express), som med stormsteg är på väg att lämna silverdivisionen för att kliv upp i högsta klassen. Seger i dagens försök – fjärde raka i silver så fall – eller en andraplats tar honom ur rikstotons näst högsta klass.<br>Loppet hedrar Jim Frick som gick bort sommaren 2020, men varken Ego Boys eller Jim Fricks minneslopp har dagens största prischeck.</p>



<p>Den tävlar istället kallbloden om i dubbelcupens final med 200.000 kronor till vinnaren. Tomas Pettersson hoppar upp bakom norske <strong>Aske Faks</strong> (e. Mjölner Herkules), som är ute efter fjärde raka segern.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/02v75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Rättviks tävlingar.</a></p>



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



<p class="has-drop-cap">4Sulkysports tipster Fredrik Persson från Simsalabim ser en intressant V75-omgång framför sig. Bland annat plitar han ned ett singelstreck för Alessandro Gocciadoro-tränade <strong>Fly Express</strong> (e. Readly Express).</p>



<p>Mats E Djuse sitter i sulkyn för tredje gången i rad och har vunnit båda gångerna hittills.<br>– Jag tycker att han var finare i travet i Norge senast. Det känns som en bra häst, men det är väl lite tuffare emot nu än de två gånger jag kört honom. Han har speciell stil, men bra inställning och vill hålla sig i trav, det är en bra egenskap, sade Mats E Djuse till V65 Direkt.</p>



<p><a href="https://sulkysport.se/spelstugan/v75-tips-rakna-med-nurmos-djuse/" target="_blank" rel="noreferrer noopener">––> Här är tipsgenomgången med viktiga punkter, spikar, drag och systemförslag på V75.</a></p>



<p><em>Vill Du spela V75 tillsammans med Sulkysport?</em><br><a href="https://www.atg.se/simsalabim/spel/307468_V75_2025-08-02_24_5" target="_blank" rel="noreferrer noopener">Här finns andelar till systemförslaget hos Simsalabim för 150 kr/andel.</a></p>



<p>Det tävlas på ytterligare en svensk bana när Lindesberg (första start 11.10) med breddlopp på menyn.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/07/250802.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></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/05/9dutchesssun-617x333.jpg" alt="" class="wp-image-588532"/><figcaption class="wp-element-caption">Dutchess Sun vann Diamantstoets final under Elitloppshelgen 2024 trots en resa utvändigt ledaren med Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5Norskt Mästerskap för varmblod och finalerna i Biris Treåringselit (tidigare Prinsesse Märthe Louises pokallopp) bjuds det på i eftermiddag på Biri – och det är en del blågult i startlistorna.</p>



<p>Daniel Wäjersten sänder <strong>Dutchess Sun</strong> (e. Maharajah) som ska försöka försvara titeln i NM för ston. Förra året vann hon som storfavorit, men nu ställs hon mot en tuff utmanare i femåriga segermaskinen <strong>Meghan B.R.</strong> (e. Face Time Bourbon) och Tom Erik Solberg. Meghan tränas av Frode Hamre – som kör Dutchess Sun!<br>Ytterligare svenskt blir det när Axevallatränaren William Ekberg reser till Biri med <strong>Creek’s Nu Love</strong> (e. Nu Pagadi).</p>



<p>I hingstklassen vann Geir Vegard Gundersen spårlottningen med Elitloppshästen <strong>Charron</strong> (e. Code Bon), som drog spår fem, medan tuffaste utmanarna <strong>Charlestone Volo</strong> (spår åtta), <strong>Just Like Heaven</strong> (spår tio) och svenskägde <strong>Stoletheshow</strong> (spår tolv) inte hade samma tur.</p>



<p>Kenneth Haugstad kvalade in <strong>Who’s Here</strong> (e. Who’s Who) som sexa till finalen i öppna klassen av Biris Treåringselit med 300.000 kronor till vinnaren, men är struken från finalen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/08/bi20250802baneprogram.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Biris tävlingar.</a></p>



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



<p class="has-drop-cap">6Igår drog Finlands största travfest igång när Kungstravsmeetinget inleddes i Uleåborg. Helgens clou är förstås de avslutande trekilometersloppen under söndagen som ska kora en finsk kung och drottning på kallblodssidan.</p>



<p>Idag möts deltagarna över 2.100 meter med autostart och i morgon blir det dubbla lopp, 1.609 meter och så avslutande 3.100 meter, samtliga med autostart.<br>Vägen till andra raka segern för titelförsvararen <strong>V.G.Voitto</strong> (e. Viesker) har underlättats av att trefaldige travkungen <strong>Evartti</strong> (e. K.M.Nopsa) tvingats lämna återbud.</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5PXzAyLjA4LjIwMjUucGRm&#038;m=oUtuLBOv3saT3tyJ4eFf1NNMUUA%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar i Uleåborg.</a></p>



<p>Vid gårdagens uppstart var årets finske Elitloppssexa och nybakade Suur-Hollola-Ajo-vinnare <strong>Massimo Hoist</strong> (e. Muscle Hill) och Hannu Torvinen det stora namnet i sprinterloppet Number One (€30.000).</p>



<p>Där fick dock Jukka Hakkarainens travare se sig besegrad av stallkamraten <strong>Callela Nelson</strong> (e. Beer Summit), som ledde hela vägen och via 1.08,5 sista 500 meterna landade på nya banrekordet 1.10,8a/1.620 meter.<br>Massimo Hoist svarade för en finfin avslutning som tvåa på 1.11,0, men hade för långt fram när attacken sattes in 350 kvar.</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/11/00261766017scoopdyga-617x411.jpg" alt="" class="wp-image-660247"/><figcaption class="wp-element-caption">Frank Gio. Foto: Scoopdyga </figcaption></figure>



<p class="has-drop-cap">7Enghiens lördagstävlingar bjuder på Grupp III-loppen Prix de Berlin (€90.000) för treåringar och Prix de Geneve (€90.000) för fyraåringar. Båda loppen avgörs över 2.875 meter.</p>



<p>Sebastien Guaratos fyraåring <strong>Frank Gio</strong> (e. Face Time Bourbon) är mest meriterad i fyraåringsloppet. Matthieu Abrivard sitter som vanligt i sulkyn, där de tuffaste motståndarna är franske <strong>Lombok Jiel</strong> (e. Enino du Pommereux), 609.325 euro, och italienske <strong>Falco Killer Gar</strong> (e. Varenne), 428.122 euro.<br>Lombok Jiel har inte startat sedan han vann Prix Ephrem Houel (€120.000) på Vincennes i början av februari.<br>Frank Gio kommer närmast från seger i Prix de Milan (€90.000) på just Enghien. Den italienske hingstens största seger kom i vintras i Prix Ourasi (€300.000) och totalt har han vunnit tolv av 21 starter och sprungit in 745.082 euro.</p>



<p>Philippe Allaires <strong>Monzon Normand</strong> (e. Hohneck) och Thierry Duvaldestin-tränade <strong>Mack de Blary</strong> (e. Face Time Bourbon) är de största namnet i treåringsloppet. En svenskfödd travare är med. Dion Tesselaar-tränade <strong>Moni Making Pace</strong> (e. International Moni), som vunnit en av livets tre starter.</p>



<p>I övrigt är det svenskfritt på Enghien och det är ingen svensktränad häst på övriga fem franska banor heller.</p>
