
<p class="has-drop-cap wp-block-paragraph">1När de möttes i Tingsryd två veckor före Elitloppet blev det seger för <strong>Barack Face</strong> (e. Ready Cash), medan <strong>A Fair Day</strong> (e. Maharajah) slutade fyra från ledningen. Sedan dess har Barack Face svikit i Mantorp och A Fair Day slutat sexa i Elitloppsförsök.</p>



<p class="wp-block-paragraph">I eftermiddag möts hästarna i Kalmarsundspokalen över sprinterdistans i <strong>Kalmar </strong>(första start 14.35), där ”Affe” blev spårvinnaren med innerspår bakom bilen. Samma utgångsläge som när han vann loppet förra året på tangerat banrekord, 1.09,1ak.</p>



<p class="wp-block-paragraph">– De satt ju där de satt i Elitloppet och hästen gjorde ett väldigt bra lopp. Vi är absolut nöjda med den insatsen. Nu är det ett drömspår igen. Det är lite olika beroende på bana men spår ett i Kalmar är väldigt bra. Då sitter Oscar och Affe där direkt. Hästen är otroligt startsnabb och har goda chanser att ta ledningen. Vi ändrar inget i utrustningen från Elitloppet, han går barfota runt om, med Finntackvagn och öppet huvudlag, säger Elisabeth Almheden till Kanal75.</p>



<p class="wp-block-paragraph">Från himmel till helvete – nåja – var det för Barack Face som efter spurtsegern i Tingsryd inte stod att känna igen för två veckor sedan.</p>



<p class="wp-block-paragraph">– När man summerar det tyckte jag inte riktigt att jag hade hästen med mig. Han var liksom lite loj hela vägen i loppet. Han hade en dålig dag och rullade över där i tempoväxlingen. Förhoppningsvis har han studsat tillbaka och kan upprepa sig, för vi har varit nöjda med honom hemma, säger Adrian Kolgjini till Kanal75.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Sulkysports expertpanel har plockat fram de bästa spikarna och roliga skrällbud till Kalmars V85-omgång och två röster som spik föll på Alessandro Gocciadoros <strong>Gaudi Laksmy</strong> i V85-inledningen. Så här säger tränaren själv om hästen som körs av Magnus A Djuse.</p>



<p class="wp-block-paragraph">– Gaudi Laksmy blev lite störd i slutkurvan senast av hästen framför. Jag kan inte säga med säkerhet att jag hade vunnit annars, men jag hade mycket krafter kvar i hästen. Jag vet inte om han är tillräckligt startsnabb för att nå ledningen, men det är en mycket stark häst och det är inte hela världen om han får gå på utsidan. Jag planerar inga ändringar, säger Alessandro Gocciadoro i sin blogg.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-kr/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Kalmars V85-omgång.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V85_2026-06-21_19_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V85_2026-06-21_19_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V85_2026-06-21_19_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/1clarissa2-617x333.jpg" alt="" class="wp-image-831924"/><figcaption class="wp-element-caption">Clarissa och Alessandro Gocciadoro. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Kalmar bjuder på fler godbitar än Kalmarsundpokalen. Som stoet som blivit Europamästarinna två år i rad. Alessandro Gocciadoros tuffa toppsto <strong>Clarissa</strong> (e. Exploits Caf) har vunnit EM för ston på Solvalla två år i rad och att hon finns på startlinjen även i år – den 19 augusti – är högst troligt.<br>Vägen dit går bland annat via Diamantstoet i Kalmar idag, där Clarissa ställs mot blott sex konkurrenter.</p>



<p class="wp-block-paragraph">I Jovialitys lopp under Elitloppshelgen blev det bara en femteplats för Clarissa.</p>



<p class="wp-block-paragraph">– Clarissa fick ett mycket tufft lopp och när jag insåg att vi inte kunde vinna så pressade jag henne inte maximalt. Min häst har tagit sig ur det loppet på rätt sätt och det blir inga ändringar, säger Alessandro Gocciadoro.</p>



<p class="wp-block-paragraph">En av Kalmars löpningsserier går i mål när det är final i montéserien och 75.000 kronor väntar i finalen, där 13 hästar sluter upp. Enbart hästar som varit med i något av de fem försöken är startberättigade. Bäst i grundserien var Stefan Granlund-tränade <strong>Make the Song</strong> (e. Make It Happen), som vann två av dem. Malin Andersson red då och sitter  i sadeln även i finalen.</p>



<p class="wp-block-paragraph">Två obesegrade hästar möts i treåringsloppet. Fredrik Perssons <strong>Isak S.H.Silvio</strong> (e. Fourth Dimension) och Stefan Perssons <strong>Wingait Stefan</strong> (e. Readly Express) har båda vunnit sina två starter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/06/21v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Kalmars tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4För den morgonpigge väntar stortävlingar på <strong>Vincennes </strong>idag med första start klockan 08.30! Storloppet Prix René Ballière (€200.000) släpps iväg klockan 12.00 för den som vill ha sovmorgon. Anledning är den värmebölja och i Paris väntar termometern stiga över 35 grader idag…</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2026/05/6idaodetillardefterat-617x333.jpg" alt="" class="wp-image-856501" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Idao de Tillard varvar ner efter Elitloppsförsöket tidigare i år. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Mötet mellan <strong>Idao de Tillard</strong> (e. Severino) och Gran Premio della Lotteria-vinnaren <strong>Free Time Jepson </strong>(e. Face Time Bourbon) är den stora godbiten under tävlingsdagen där det tävlas om totalt 1.408.000 euro i nio lopp.</p>



<p class="wp-block-paragraph"><strong>Prix René Ballière</strong> (€200.000)<br>4-11 år.<br><strong>Priser: </strong>90.000-50.000-28.000-16.000-10.000-4.000-2.000 euro<br><em>2.700 meter.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Kusk/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Ibiscus Man</strong> (e. Booster Winner) – David Thomain/Romain Christian Larue</li>



<li><strong>Fiftyfour </strong>(e. Fourth Dimension) – Pierre-Yves Verva/Tomas Malmqvist</li>



<li><strong>Harmony du Rabutin </strong>(e. Royal Dream) – David Bekaert/Guillaume Richard Huguet</li>



<li><strong>Cobra Killer Gar</strong> (e. Readly Express) – Gabrielle Gelormini/Erik Bondo</li>



<li><strong>Keep Going</strong> (e. Follow You) – Mathieu Mottier</li>



<li><strong>Free Time Jepson </strong>(e. Face Time Bourbon) – Andrea Guzzinati/Alessandro Gocciadoro</li>



<li><strong>Horchestro </strong>(e. Sam Bourbon) – Eric Raffin/Guillaume Richard Huguet</li>



<li><strong>Ibiki de Houelle</strong> (e. Love You) – Alexis Collette/Kevin Leblanc</li>



<li><strong>Krack Time Atout </strong>(e. Face Time Bourbon) – Franck Nivard/Sébastien Guarato</li>



<li><strong>Fulton </strong>(e. Royal Dream) – Jean-Michel Bazire/Nicolas Bazire</li>



<li><strong>Hooker Berry </strong>(e. Booster Winner) – Antoine Lherete</li>



<li><strong>Idao de Tillard</strong> (e. Severino) – Thierry Duvaldestin</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5 Den extrema värmen i Frankrike har tvingat arrangörerna att tidigarelägga tävlingarna på Vincennes idag. Beslutet har fattats för att skydda hästar och personal, men väntas samtidigt påverka PMU:s omsättning negativt.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/06/immowegmannv2amrkaucnaunsplash.jpg" alt="" class="wp-image-863687"/><figcaption class="wp-element-caption">Över 35 grader väntas det bli Paris idag.</figcaption></figure>



<p class="wp-block-paragraph">Enligt PMU:s nätverksdirektör Sylvain Dominé brukar hög värme leda till färre besökare hos spelombuden eftersom många väljer att stanna hemma. För att möta utmaningen har PMU informerat sina cirka 14.000 försäljningsställen via telefonsamtal, den interna appen ”PMU et vous”, spelterminaler och tv-kanalen Equidia.</p>



<p class="wp-block-paragraph">Fokus ligger på att skapa aktivitet mellan klockan 10.00 och 14.00 genom frukost- och bruncharrangemang hos spelombuden. Samtidigt medger Dominé att situationen är ovanlig och att det är svårt att bedöma hur stor påverkan på omsättningen blir.</p>



<p class="wp-block-paragraph">För att locka spelare behåller PMU jackpotten på en miljon euro i Quinté+ samt lanserar flera extra bonuskampanjer. Även den digitala plattformen PMU Play förstärks med särskilda erbjudanden och en e-jackpot på 100.000 euro.</p>



<p class="wp-block-paragraph">Trots satsningarna räknar PMU med att den förändrade tävlingsdagen kommer att få ekonomiska konsekvenser för både spelnätverket och travsportens finansiering.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/macahancjjm240820adamstromstalltz-617x418.jpg" alt="" class="wp-image-624189"/><figcaption class="wp-element-caption">Macahan. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Det blir också en hel del blågula inslag under Vincennes söndagstävlingar. I ett fem- och sexåringslopp – Prix de Grasse (€90.000) – startar Maria Törnqvist <strong>Macahan</strong> (e. Maharajah) och i samma lopp plockar Jörgen Westholm ut <strong>Caviar From Mine</strong> (e. S.J.’s Caviar). </p>



<p class="wp-block-paragraph">Mer Westholm-tränat blir det i Prix de Grosbois (€90.000) och där går <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) ut med Alexandre Abrivard i sulkyn.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-06-21/7500" target="_blank" rel="noreferrer noopener">Här hittar du startlistorna till Vincennes tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Idag förvandlas Krieaubanan i Wien till centrum för den österrikiska travsporten. Då avgörs den 141:a upplagan av Derbyt. Inför årets upplaga riktas mycket av uppmärksamheten mot stoet <strong>Ivana Venus </strong>(e. Explosive Matter) och kusken Christoph Fischer.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/06/ivanavenus.jpg" alt="" class="wp-image-864199"/><figcaption class="wp-element-caption">Ivana Venus. Foto: Krieau</figcaption></figure>



<p class="wp-block-paragraph">Det Gregor Krenmayr-tränade stoet imponerade stort i Derby-Versuchsrennen (€10.000) den 7 juni i Wien och där Ivana Venus och Christop Fischer kontrollerade loppet från spets på 1.15,7a/2.600 meter och vann överlägset. Trots Ivana Venus starka prestation – hon har dessutom vunnit samtliga fem starter i år – betraktas årets Derby som ett av de mest öppna på många år.</p>



<p class="wp-block-paragraph"><strong>Österrikiskt Derby</strong> (€50.000)<br>Fyraåringar.<br><em>2.600 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Darling Venus</strong> (e. Baltimore As) – Gregor Krenmayr</li>



<li><strong>Merci Sherie </strong>(e. The Bank) – Hubert Brandstätter</li>



<li><strong>Melody’s Fabula </strong>(e. Fabulous Wood) – Gerhard Mayr</li>



<li><strong>Ivana Venus </strong>(e. Explosive Matter) – Christoph Fischer</li>



<li><strong>Power Winnetou</strong> (e. Booster Winner) – Cornelia Mayr</li>



<li><strong>Power Mystic </strong>(e. Maharajah) – Michael Schmid</li>



<li><strong>Power Fabulous </strong>(e. Fabulous Wood) – Franz Konlechner</li>



<li><strong>Black Speed </strong>(e. Orlando Vici) – Thomas Royer</li>



<li><strong>Secret Venus</strong> (e. Baltimore As) – Christoph Schwarz</li>



<li><strong>Jackpot Venus</strong> (e. Light Kronos) – Johan Lichtenwörther</li>



<li><strong>Mus Musculus</strong> (e. Light Kronos) – Thomas Pribil</li>



<li><strong>Wilander</strong> (e. Make It Happen) – Jaap van Rijn</li>



<li><strong>Danilo HS </strong>(e. Light Kronos) – Matthias Schambeck</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Raka spåret för ”Affe”?
Revanschmöte mellan två stora profiler. Expertpanel litar på Gocciadoro. Sjätte raka i Österrikiskt Derby? Morgontävlingar i Paris å grund av värmebölja.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
