
<p class="has-drop-cap">1 Vinnaren av sprinterloppet Finlandia-Ajo (€200.000) på Vermo erhåller en biljett till Elitloppet, men det tävlas om platser i fler av Solvallas miljonlopp i Finland till helgen. Både en plats i Elitkampen för kallblod och Harper Hanovers lopp – en miljon kronor i förstapris i båda loppen – ligger i potten.</p>



<p><strong>Startlista Finlandia-Ajo (€200.000)</strong><br>1.620 meter autostart, Vermo söndag:<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Crepe Match</strong> (e. Creatine) – Olli Koivunen (Harri Koivunen)</li>



<li><strong>Lozano di Quattro</strong> (e. Trixton) – Tobias J Gustafsson (Per Eriksson)</li>



<li><strong>Combat Fighter</strong> (e. From Above) – Ari Moilanen (Antti Ojanperä)</li>



<li><strong>Decision Maker</strong> (e. Nuncio) – Carl Johan Jepson (Stefan Melander)</li>



<li>B<strong>etting Pacer </strong>(e. Maharajah) – Björn Goop</li>



<li><strong>Callela Nelson </strong>(e. Beer Summit) – Hannu Torvinen (Jukka Hakkarainen)</li>



<li><strong>Double Deceiver</strong> (e. Cantab Hall) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>Global Withdrawl </strong>(e. S.J.’s Caviar) – Tommi Kylliäinen (Matias Salo)</li>



<li><strong>Clarissa </strong>(e. Exploit Caf) – Santtu Raitala (Alessandro Gocciadoro)</li>



<li><strong>Mellby Jinx</strong> (e. Ready Cash) – Daniel Wäjersten</li>
</ol>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5IXzA0LjA1LjIwMjUucGRm&#038;m=rqK%2BtCJwu7WMzGSd%2FPJTOhyYj%2FA%3D&#038;service=pdftmp" data-type="link" data-id="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5IXzA0LjA1LjIwMjUucGRm&#038;m=rqK%2BtCJwu7WMzGSd%2FPJTOhyYj%2FA%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vermos tävlingar idag.</a></p>



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



<p class="has-drop-cap">2 Finlandia-Ajo har körts sedan franske <strong>Ejakval </strong>(e. Kerjacques) vann 1980 och avgjordes större delen av 1980-talet med försök och final samma dag. Sedan 1992 har det handlat om ett enda lopp.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/cokstilefinlandiaajo-617x411.jpg" alt="" class="wp-image-296138"/><figcaption class="wp-element-caption">Cokstile och Christoffer Eriksson vid vinsten i Finlandia-Ajo. Foto: Terhi Piispa-Helisten</figcaption></figure>



<h2 class="wp-block-heading">Här är de nio snabbaste vinnarna:</h2>



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



<ul class="wp-block-list">
<li>2022 <strong>Cokstile </strong>(e. Quite Easy) – Christoffer Eriksson (Erik Bondo) – 1.09,6a</li>



<li>2017<strong> D.D.’s Hitman</strong> (e. Donato Hanover) – Ulf Ohlsson (Petri Puro) – 1.09,8a</li>



<li>2020 <strong>Zarenne Fas</strong> (e. Varenne) – Santtu Raitala (Jerry Riordan) – 1.09,9a</li>



<li>2021 <strong>Hickothepooh</strong> (e. Triton Sund) – Vidar Hop (Trond Anderssen) – 1.09,9a</li>



<li>2016 <strong>Tycoon Conway Hall </strong>(e. Conway Hall) – Steen Juul – 1.10,4a</li>



<li>2024 <strong>Stoletheshow</strong> (e. Dream Vacation) – Magnus A Djuse (Frode Hamre) – 1.10,4a</li>



<li>2019 <strong>Readly Express</strong> (e. Ready Cash) – Björn Goop (Timo Nurmos) – 1.10,5a</li>



<li>2010 <strong>Quarcio du Chene</strong> (e. Capriccio) – Björn Goop (Olle Goop) – 1.10,6a</li>



<li>2023 <strong>Stoletheshow </strong>(e. Dream Vacation) – Magnus A Djuse (Frode Hamre) – 1.10,6a</li>
</ul>



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



<p class="has-drop-cap">3 Gran Premio della Lotteria avgörs på Agnano-banan idag med tre försök (€25.300) och final (€660.000) och Alessandro Gocciadoro har lockat ner Magnus A Djuse till Neapel för att köra <strong>Always Ek</strong> (e. Filipp Roc), som vunnit två Grupp I-lopp med Magnus i sulkyn. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/3alwaysek2-617x333.jpg" alt="" class="wp-image-588486"/><figcaption class="wp-element-caption">Always Ek efter försöksvinst i Sweden Cup. Foto Mathias Hedlund/Sulkysport.</figcaption></figure>



<p>Alessandro Gocciadoro dominerar – i alla fall på papperet – i Europas näst största sprinterlöpning efter Elitloppet med sju av 23 hästar i försöken sedan <strong>Vernissage Grif</strong> strukits. De tre främsta från varje försök går vidare till finalen.</p>



<h2 class="wp-block-heading">Försök I:</h2>



<p><strong>Namn – Far – Tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Deus Zack</strong> (e. Victor Gio) – Edoardo Loccisano</li>



<li><strong>Always Ek </strong>(e. Filipp Roc) – Alessandro Gocciadoro</li>



<li><strong>Denver Gio</strong> (e. Southwind Frank) – Fausto Barelli</li>



<li><strong>Dylan Dog Font </strong>(e. Ringostarr Treb) – Marco Azzaroni</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Holger Ehlert</li>



<li><strong>Ampia Mede Sm</strong> (e. Ganymede) – Erik Bondo</li>



<li><strong>Click Bait</strong> (e. Cantab Hall) – Alessandro Gocciadoro</li>



<li><strong>Bengurion Jet </strong>(e. Maharajah) – Alessandro Gocciadoro</li>
</ol>



<h2 class="wp-block-heading">Försök II:</h2>



<ol class="wp-block-list">
<li><strong>Dany Capar </strong>(e. Exploit Caf) – Alessandro Gocciadoro</li>



<li><strong>Alrajah One </strong>(e. Maharajah) – Marco Azzaroni</li>



<li><strong>Usain Töll</strong> (e. Googoo Gaagaa) – Mattia Orlando</li>



<li><strong>Bleff Dipa</strong> (e. Mister J.P.) – Holger Ehlert</li>



<li><strong>Chance Ek</strong> (e. Nad al Sheba) – Fausto Barelli</li>



<li><strong>Dubhe Prav</strong> (e. Robert Bi) – Santo Mollo</li>



<li><strong>Banderas Bi</strong> (e. Ganymede) – Alessandro Gocciadoro</li>



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



<h2 class="wp-block-heading">Försök III:</h2>



<ol class="wp-block-list">
<li><em>Vernissage Grif – struken</em></li>



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



<li><strong>Emma dei Veltri</strong> (e. Maharajah) – Gennaro Casillo</li>



<li><strong>Dimitri Ferm</strong> (e. Nad al Sheba) – Marco Azzaroni</li>



<li><strong>Ideal San Leandro</strong> (e. Timoko) – Richard Westerink</li>



<li><strong>Diamond Truppo</strong> (e. Varenne) – Alessandro Gocciadoro</li>



<li><strong>Callisto </strong>(e. Nad al Sheba) – Mattia Orlando</li>



<li><strong>Dali Prav</strong> (e. Donato Hanover) – Fausto Barelli</li>
</ol>



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



<p class="has-drop-cap">4 Lindesberg smygstartade säsongen med två lopp i juniorchansen i samband med en ponnytravdag den 21 april, men i eftermiddag blir det årspremiär på allvar. Och det blir en riktig rivstart vad gäller uppmärksamhet.</p>



<p>När svenskt V75-spel till en V75-omgång på Vermo idag ställdes in blir det istället Grand Slam 75-spel från <strong>Lindesberg</strong> (första start 13.45). En annorlunda omgång för ett stort riksspel dessutom. Breddplus med 15.000 kronor i förstapris och för hästar med högst 800 startpoäng är det som gäller hela tävlingsdagen!</p>



<p>– Det blev en bonus för oss med större fokus. Vi skjuter till extra prispengar som gör att delningspropositionen nu kan delas i ytterligare lopp, säger Lindesbergs travbanechef Björn Andersson till travförbundets hemsida.</p>



<p>Sju lopp (av nio) från en delningsproposition för hästar upp till miljonen intjänat som spårtrappor utgör kupongen till GS75-spelet.</p>



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



<p class="has-drop-cap">5 Högre sportsliga toppar bjuds det på <strong>Hagmyren</strong> (första start 14.00), där det handlar om ”vanliga” propositioner och 25.000-50.000 kronor i förstapris i nio lopp.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/06/anderseriksson-617x333.jpg" alt="" class="wp-image-182657"/><figcaption class="wp-element-caption">Anders Eriksson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Anders Eriksson har en spännande travare i fyraårige <strong>Griffons Wine</strong> (e. Maharajah), som ifjol vann en av fyra starter som treåring. 2025 hade han vägrat förlora och noterat 1.15-tider i två raka segrar under våren när bågen spändes mot V75 på Romme i påskas. Då tvingades dock Anders stryka på grund av sårskada. Nu har Griffons Wine laddat om och jagar tredje raka segern i ett dubbelklasslopp.</p>



<p>I Hagmyrens första lopp kommer landets kanske minsta kallblodstravare ut till start.</p>



<p>– Hon är extremt liten. Hon är 135 centimeter hög så det är nästan som en ponny, men hon har en riktig vinnarskalle, sade ägaren och kusken Johanna Stark efter att <strong>Gangstras</strong> (e. Tekno Jerven) segrat i Östersund i senaste starten för en månad sedan.</p>



<p>Gangstras har gjort två starter hittills och slutat tvåa-etta och nu startar hon från 40 meters tillägg i ett 14 hästar stort treåringslopp för ston.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/04/250504.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/04/250504.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap">6 Fyra av tio hästar är inbjudna till Copenhagen Cup sedan Charlottenlund utnyttjat samtliga fyra wild cards. Förutom Mattias Djuses <strong>Hustle Rain</strong> (e. Raja Mirchi) har det delats ut friplåtar till<strong> Hades de Vandel</strong> (e. Ganymede), <strong>Just Hans</strong> (e. Maharajah) samt Andrian Kolgjinis fjolårsvinnare <strong>Barack Face</strong> (e. Ready Cash).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/ay2x0099kopier-617x411.jpg" alt="" class="wp-image-582742"/><figcaption class="wp-element-caption">Barack Face och Adrian Kolgjini vid senaste segern, i Copenhagen Cup i maj förra året. Foto Kjeld Mikkelsen/KM FOTO</figcaption></figure>



<p>På måndag klockan 14.00 sker lottningen till Copenhagen Cup på Charlottenlunds <a href="https://www.facebook.com/danskhestevaeddeloeb" data-type="link" data-id="https://www.facebook.com/danskhestevaeddeloeb" target="_blank" rel="noreferrer noopener">Facebook-sida</a>. Löpningen avhålls söndagen den 11 maj över distansen 2.011 meter. Förstapriset i loppet uppgår till 400.000 danska kronor.</p>



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



<p class="has-drop-cap">7 Sofie Ericsson avslutade Dam-EM för amatörer i dur – seger med <strong>Mozart Boko</strong> (e. Chelsea Boko) på 1.14,7a/2.100 meter – på Victoria Park i Wolvega och kunde klättra upp till en femteplats.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/img17441-617x463.jpg" alt="" class="wp-image-714748"/><figcaption class="wp-element-caption">Sofie Ericsson efter segern med Mozart Boko. Foto: Bengt Larwik</figcaption></figure>



<p>Vann gjorde norskan Silje Kristin Ellertsen.</p>



<h2 class="wp-block-heading">Fem-i-topp Dam-EM för amatörer</h2>



<p><strong>Namn – Land – Poäng</strong></p>



<ol class="wp-block-list">
<li><strong>Silje Kristin Ellertsen</strong> – Norge – 42</li>



<li><strong>Angelique Scotti</strong> – Schweiz – 36</li>



<li><strong>Eszter Takacs </strong>– Ungern – 34</li>



<li><strong>Hiltje Tjaisma</strong> – Holland – 33</li>



<li><strong>Sofie Ericsson</strong> – Sverige – 32</li>
</ol>
