
<p class="has-drop-cap wp-block-paragraph">1 <strong>Jägersro</strong> (första start 13.00) och Skånska Travamatörklubben bjuder in till Gentlemannadagen, som med kringaktiviteter och deltagare från Melodifestivalen på plats brukar dra stora åskådarmassor till Skånebanan. Publikrekordet sattes 2018 med 19.243 personer.</p>



<p class="wp-block-paragraph">Skånska Travamatörklubben bildades den 7 mars 1946 och har varit mycket aktiv under årens lopp och var bland annat idéspruta till Svenskt och Nordiskt Mästerskap för amatörer. I maj 1972 hölls den första upplagan av Gentlemannadagen och då var skådespelaren och hästuppfödaren Jarl Kulle det stora dragplåstret på Jägersro.</p>



<figure class="wp-block-image size-sulky-stor2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/gentlemannadagen-938x472.jpg" alt="" class="wp-image-445338"/><figcaption class="wp-element-caption">Till Stortorget i Malmö drog Skånska Travamatörklubben med häst och vagn för att väcka intresset för premiären av Gentlemannadagen 1972. Foto Jägersro</figcaption></figure>



<p class="wp-block-paragraph">På travovalen då? Det största fyrbenta namnet är Jerry Riordan-tränade italienaren <strong>Far Wise As</strong> (e. Face Time Bourbon), som hade en fin treåringssäsong med segern i korta E3-finalen som höjdpunkt. I år har han gjort två start och efter andraplatsen i försök till Kungapokalen galopperade han bort sig i finalen. Gustav Johansson hoppar upp i vagnen för andra gången. Förra sommaren vann duon ett försök till korta Breeders Course tillsammans.</p>



<p class="wp-block-paragraph">Jägersro är svensk huvudbana på Kristi Himmelsfärdsdag och på V64-spelet vankas jackpot med drygt 850.000 kronor extra i sexrättspotten.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Sveriges montéetta de senaste åren, Jonathan Carrè, lämnade handikapp till konkurrenterna när han inledde året på fransk mark och fortfarande har det ”bara” blivit åtta segrar i Sverige under 2025. I söndags visade han ryttarform när han vann Montéeliten på Solvalla med Mathieu Mottier-tränade <strong>Kerry Love</strong> (e. Brillantissime). Efter segern följde Kerry Love med hem till Carré och sambon Constanza Flores för fortsatt matchning i Norden.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/05/3kerrylove.jpg" alt="" class="wp-image-723104"/><figcaption class="wp-element-caption">Kerry Love och Jonathan Carre spurtade till seger i Montéeliten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Idag reser Åbylicensierade Carré norrut till Bergsåker, där det bjuds 100 procent monté idag. Det är nämligen sadellopp för hela slanten när åtta lopp ska avverkas. Ryttarna får dock rida högst fyra av dessa och Carré är en av elva ryttare som har maximalt antal ritter.</p>



<p class="wp-block-paragraph">Två lopp sticker ut penningmässigt, där Svensk Monté Riksorganisations lopp – ett för vardera ras – bjuder 75.000 kronor i förstapris i varje. Carré har två intressanta ritter i <strong>Järvsö Kurt</strong> (e. Järvsö Björn) och <strong>Hopium</strong> (e. Pim Quick). Bland dagens montédebutanter märks två spännande kort från Sandra Erikssons stall: <strong>Gorm</strong> (e. Dotterud Teddy), 1,9 miljoner, och <strong>Devil’s Tongue</strong> (e. Zola Boko), 1,5 miljoner.</p>



<p class="wp-block-paragraph">Av ryttarna på tio-i-topp rider trion Carré, Julia Andersson och Julia Smedman på Bergsåker idag.</p>



<h2 class="wp-block-heading">Segerrikaste montéryttare i Sverige 2025</h2>



<p class="wp-block-paragraph"><strong>Ryttare, hemmabana – Resultat – Prispengar (kr)</strong></p>



<ol class="wp-block-list">
<li><strong>Sofia Adolfsson</strong>, Örebro – 37 st: 12-7-5 – 787.600 kr</li>



<li><strong>Agnes Larsson</strong>, Solvalla – 27 st: 9-5-2 – 539.300 kr</li>



<li><strong>Jonathan Carré</strong>, Åby – 43 st: 8-8-9 – 989.200 kr</li>



<li><strong>Julia Andersson</strong>, Mantorp – 28 st: 5-4-2 – 383.200 kr</li>



<li><strong>Malin Andersson</strong>, Åby – 25 st_ 5-3-3 – 278.400 kr</li>



<li><strong>Saga Laursen</strong>, Axevalla – 38 st: 5-2-8 – 384.400 kr</li>



<li><strong>Iina Aho</strong>, Axevalla – 41 st: 3-10-5 – 470.700 kr</li>



<li><strong>Ailin Berg-Almaas</strong>, Axevalla – 18 st: 3-4-0 – 209.900 kr</li>



<li><strong>Julia Smedman</strong>, Solvalla – 31 st: 3-3-1 – 238.700 kr</li>



<li><strong>Linnea Djupdahl</strong>, Halmstad – 9 st: 3-2-1 – 156.000 kr</li>
</ol>



<p class="wp-block-paragraph">Statistiken gäller ritter på svenska banor.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 <strong>Lindesberg</strong> (start 14.00) avrundar under eftermiddagen med en högintressant årsdebutant. Timo Nurmos-tränade <strong>Kojak Sisu</strong> (e. Muscle Mass) tangerade Ecurie D:s världsrekord när han som treåring vann Big Noon Pokalen på 1.12,2/1.640 meter voltstart. Ifjol som fyraåring blev det bara två starter &#8211; i försök och final av Svenskt Travderby. Kojak slutade tvåa i uttagningsloppet, men galopperade bort sig i finalen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/kojaksisumedm230913adamstromstalltz-617x423.jpg" alt="" class="wp-image-496076"/><figcaption class="wp-element-caption">Kojak Sisu vinner från spets med Mats E Djuse i sulkyn. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Nu väntar första starten 2025 när Kojak Sisu kommer ut med bricka åtta bakom bilen i en spårtrappa med Magnus A Djuse i vagnen.</p>



<p class="wp-block-paragraph">Det bjuds välfyllda lopp i Lindesberg. Ett treåringslopp stängt vid 25.000 kronor delades till och med i två med elva hästar i vardera lopp. Bland dessa finns tio debutanter och ytterligare tre treåriga nykomlingar dyker upp i vanliga nolloppet.</p>



<p class="wp-block-paragraph">Och på tal om treåringar…Robert Bergh startar sin fine debutvinnare <strong>Valla d’Gaagaa</strong> (e. Googoo Gaagaa) – 1.16,1m i Årjäng för drygt två veckor sedan – mot äldre hästar. Bergh är själv på Jägersro och anlitar Carl Johan Jepson i Lindesberg.</p>



<p class="wp-block-paragraph"><strong>Skellefteå</strong> (första start 12.10) är först ut med breddlopp på menyn och Gunnel Fredriksson plockar ut årsdebuterande <strong>Icegirl L.A.</strong> (e. Coktail Jet), som i näst senaste starten testades i V75-lopp hemma i Boden.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/05/250529.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/05/250529.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 För att besegra <strong>Ginostrabliggi </strong>(e. Muscle Hill) under Elitloppshelgen krävdes världsrekord av <strong>Wise Guy</strong> (e. Face Time Bourbon)…Philippe Allaires stjärna slickar inte såren speciellt länge och den 7 juni åker han till San Siro och där blir det ett riktigt toppmöte i Gran Premio Nazionale (€154.000) över medeldistans.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/mauricedegheest1-617x346.jpg" alt="" class="wp-image-675354"/><figcaption class="wp-element-caption">Golden Gio spurtar enkelt hem Prix Maurice de Gheest för Matthieu Abrivard. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Dit är nämligen också Sébastien Guarato-tränade <strong>Golden Gio</strong> (e. Face Time Bourbon) anmäld. Den senare har vunnit dubbla semi-classique-vinster på Vincennes i år – Prix Maurice de Gheest (€120.000) och Prix Paul Viel (€120.000) – för Matthieu Abrivard.</p>



<p class="wp-block-paragraph">För några månader sedan – då stod Ginostrabliggi med sex raka segrar – utmanade Golden Gios ägare Philippe Allarie i ett <a href="https://sulkysport.se/ett-matchrace-vart-namnet/" data-type="link" data-id="https://sulkysport.se/ett-matchrace-vart-namnet/" target="_blank" rel="noreferrer noopener">matchrace</a> om 500.000 euro på Vincennes över 2.850 meter och där Ginostrabliggi skulle få 50 meters försprång. Det blev aldrig av, men den 7 juni kan vi få ett kvitto vem som är bäst i duon.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Skatteverket ändrar sig och godtar nu att tävling med travhäst är ekonomisk verksamhet. Det skriver travförbundet på sin hemsida. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/skatteverketgenre-617x333.jpeg" alt="" class="wp-image-465755"/><figcaption class="wp-element-caption">Skatteverket har ändrat sig. Foto: Fialotta Bratt</figcaption></figure>



<p class="wp-block-paragraph"><em>”Efter att kammarrätterna i Sundvall och Göteborg i början av maj ansåg att tävling med travhäst mot garanterad prispeng/startpeng är ekonomisk verksamhet, har Skatteverket nu ändrat sin ståndpunkt som inneburit att tävling med travhäst mot garanterad prispeng/startpeng aldrig kan vara ekonomisk verksamhet.”</em></p>



<p class="wp-block-paragraph"><a href="https://www.travsport.se/arkiv/nyheter/2025/maj/skatteverket-andrar-sig-och-godtar-nu-att-tavling-med-travhast-ar-ekonomisk-verksamhet/" data-type="link" data-id="https://www.travsport.se/arkiv/nyheter/2025/maj/skatteverket-andrar-sig-och-godtar-nu-att-tavling-med-travhast-ar-ekonomisk-verksamhet/" target="_blank" rel="noreferrer noopener">Läs hela pressmeddelandet här.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/maurofantini-617x333.jpg" alt="" class="wp-image-558894"/><figcaption class="wp-element-caption">Mauro Fantini tillsammans med Helen A Johansson och Johan Untersteiner efter Dear Friends seger i Helens lopp på Vincennes Prix d&#8217;Amérique-dag 2020. Foto Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Den hästägare som lade grund till ”segern” i Göteborgs kammarrätt var Mauro Fantini, känd som delägare i toppstoet <strong>Dear Friend</strong>. </p>



<p class="wp-block-paragraph">– Först vann jag i högsta förvaltningsrätten men Skatteverket överklagade och nu vann jag i kammarrätten. Skatteverket ville till och med ha tillbaka all moms som jag hade fått under fem år och dra tillbaka min momsbehörighet, skriver Mauro Fantini på facebook. </p>



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



<p class="has-drop-cap wp-block-paragraph">6 Två hästar till start har Marie Norberg idag i <strong>Rambouillet</strong> (kl. 14.000) och först ut är <strong>Justess Viking</strong> (e. Ubriaco) i Prix du Colonel Maurice Poirier (€21.000) och det sexåriga stoet står med 25 meters tillägg i ett lopp över grunddistansen 2.800 meter med 9.450 euro i förstapris.</p>



<p class="wp-block-paragraph">Marie Norberg sitter själv i sulkyn och det gör hon också bakom <strong>Kool Viking </strong>(e. Let’s Go Along) i Prix de la Bergerie Nationale (€16.500) över 2.800 meter. Där väntar 7.425 euro till vinnaren.</p>



<p class="wp-block-paragraph">Till <strong>Abbeville </strong>(kl 14.00) åker Ron Kuiper med Stall Escapades fyraåriga debutant <strong>Lamelle du Nord</strong> (e. Gu d’Heripre) i Prix Face Time Bourbon (€12.500) i ett lopp över 2.300 meter. Förstapriset uppgår till 5.265 euro och Ron Kuiper tar hand om tömmarna.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Anna Jönsson kan berätta att två föl föddes samma natt hos Stall Frö på Öland. Både <strong>Come and Smile</strong> (e. Zola Boko-Sheryl Boko), 1.20,1m, och <strong>Honeybee Frö</strong> (e. Father Patrick-Adena Ås), 1.12,4ak/342.100 kr, har fått söner efter Fourth Dimension respektive Readly Express.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/1000008797-617x822.jpg" alt="" class="wp-image-725090"/><figcaption class="wp-element-caption">Honeybee Frö med sin son efter Readly Express. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Honeybee Frö har fått sin andra avkomma och ifjol nedkom hon med en hingst efter Bold Eagle. Honeybee Frö är undan <strong>Adena Ås</strong> (e. Allstar Hall), 1.14,7ak/154.050 kr, vilken också lämnat <strong>Bee Frank Frö</strong> (e. Southwind Frank), 1.14,4ak/148.400 kr, och <strong>Milk and Honey</strong> (e. Bold Eagle), 1.14,0am/190.500 kr.</p>



<p class="wp-block-paragraph">Mormor Adena Ås kommer från en syskonskara som innehåller fyra miljonärer; <strong>Covington Ås</strong> (1.835.450 kr), <strong>Fail Ås </strong>(1.487.205 kr), <strong>Kasmir Ås</strong> (1.258.304 kr) och <strong>Fighting Ås</strong> (1.140.500 kr).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/05/1000009011-617x823.jpg" alt="" class="wp-image-725091"/><figcaption class="wp-element-caption">Come and Smile tillsammans med sitt hingstföl efter Fourth Dimension. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Come and Smile har tidigare lämnat <strong>Sourire Frö</strong> (e. Wishing Stone), 1.10,2ak*/2.748.500 kr, och <strong>One Mile Smile Frö</strong> (e. Flocki d’Aurcy), 1.13,4ak/135.000 kr.</p>



<p class="wp-block-paragraph">Come and Smile ingår i samma syskonskara som bland andra <strong>Ninepoints Jazzy </strong>(e. Steinlager), 1.14,3am/360.900 kr, och <strong>Ninepoints Sheryl</strong> (e. Gigant Neo), 1.15,2am/220.268 kr.</p>



<p class="wp-block-paragraph">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 tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Förgyller Gentlemannadagen?
Årets högsta publiksiffra på Jägersro idag. Derbyfinalist tillbaka. Skatteverket ändrar ståndpunkt. Stjärnmöte i Milano. Dubbla föl hos Stall Frö.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
