
<p class="has-drop-cap">1 Efter en breddloppsdag och fyra lunchtrav blir det säsongens första tävlingsdag i huvudfokus i Trav-Sverige och kvällstrav på <strong>Visbytravet </strong>(första start 18.20). Daniel Redén gästade lunchtravet förra tisdagen och vände hem med tre segrar och banrekord för <strong>Sister Nell </strong>(e. Propulsion) på sex starter för stallets hästar.</p>



<p>Ikväll är Redén tillbaka på Gotland för sex nya starter med stallets hästar. Bland dessa finns sexfaldige miljonären <strong>Variegated </strong>(e. Chapter Seven), som senast startade i Kungapokalens final (oplacerad). Nu möter han äldre hästar från spår åtta i snabbloppet.</p>



<p>– Variegated fick ett tufft lopp i Kungakannan och var ursäktad. Jag tyckte ändå att han höll bra och det är en bra häst. Tyvärr har han dåligt med startpoäng och har inte kommit med i några lopp efter det, så det kan ha blivit lite långt mellan starterna för att ha toppform. Han känns ändå bra i jobben och tanken är att han ska ut i Sprintermästaren efter detta. Det blir barfota runt om och bike, säger Daniel Redén på sin hemsida <a href="http://reddis.se/">reddis.se</a>.</p>



<p>Tuffaste motståndaren kan vara Oskar J Andersson-tränade <strong>Readly Lavec </strong>(e. Bird Parker), som gör årsdebut med nästan tre miljoner kronor på kontot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/readlylavec4-617x333.jpg" alt="" class="wp-image-449681"/><figcaption class="wp-element-caption">Readly Lavec vann sIlverdivisionens final 2023 tillsammans med  Oskar J Andersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>En annan är treårige hingsten <strong>King Dee Zet </strong>(e. Hard Livin-Delicious), som gjorde debut med dunder och brak i Bollnäs i början av maj när han vann på 1.15,1/2.140 meter voltstart.</p>



<p>– King Dee Zet var verkligen en positiv överraskning i debuten och han vann på ett väldigt bra sätt. Allt har sett fint ut efteråt och han kommer göra ett bra lopp igen, säger Daniel Redén om sonen till hans superstjärna och trefaldiga världsrekordtravare <strong>Delicious</strong>.</p>



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



<p class="has-drop-cap">2 Rollen som saxbana ikväll intar <strong>Åby</strong> (första start 18.30) och det dyker upp flera intressanta namn. I samarbetet mellan Åby, Jägersro, Halmstad, Charlottenlund och Bjerke ingår flera löpningsserier med finaler på alla banor. En av dessa är Summer Meeting Halmstad för hästar upp till 700.000 kronor, där de två främsta i fem försök går till finalen i Halmstad på Sprintermästarkvällen den 2 juli med 100.000 kronor till vinnaren.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/peteruntersteiner-617x333.jpg" alt="" class="wp-image-452165"/><figcaption class="wp-element-caption">Peter Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Till den kvällen laddar gärna far och son Untersteiner lite extra och i kvällens försök ska pappa Peter försöka lotsa <strong>Global Futurity </strong>(e. Greenshoe) till finalen. Den toppstammade femåringen vann V85-lopp i februari och återkommer efter drygt två månaders tävlingsuppehåll.</p>



<p>Han har en hel del att leva upp till också Global Futurity, som lillebror till fyra miljonärer – däribland <strong>Global Adventure </strong>(5,7 miljoner) – och den färska vinnaren av Guldstoet på Axevalla, treåriga <strong>Global Halo</strong> (e. Ready Cash).</p>



<p>Bland motståndarna i kvällens finns Joakim Lövgren-tränade <strong>Epicure D.E.</strong> (e. Up And Quick), som vunnit tre av fem starter 2026.</p>



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



<p class="has-drop-cap">3 Sandra Erikssons finskfödde miljonär <strong>B.Sacamano</strong> (e. Prodigious) visade fin form den här tiden förra året. Han vann bland annat Midsommarkransen i Skellefteå och besegrade då nybakade Elitloppsförsöksvinnaren och svenske rekordhållaren <strong>Mellby Jinx</strong> (e. Ready Cash). </p>



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



<p>Sedan dess har inte B.Sacamano vunnit lopp, men kanske är det dags på dagens lunchbana <strong>Umåker</strong> (första start 12.20). Där återkommer hästen efter tre månaders tävlingsuppehåll och som rikast i fältet inleder han från spår åtta i en spårtrappa.</p>



<p>Hästägarsatsningen Kallsvenskan med tio treåriga kallblod i lika många stall rullar vidare och i nolloppet möts två av deltagarna. Jan-Olov Persson fick aldrig chansen att välja häst till sitt stall utan fick ta den som var över efter att övriga valt sin kandidat. För Persson innebar det att <strong>Sättrans Gulliver </strong>(e. Tekno Odin) tog plats hos Persson och nu är det dags för tävlingsdebut med Mats E Djuse i vagnen.</p>



<p>Bland motståndarna, från 20 meters tillägg, finns <strong>Mån Teddy</strong> (e. Dotterud Reddy), som slutat sjua och trea i sina två starter för Robert Skoglund.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/260611.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/06/260611.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens 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/2026/03/idaodetillard-617x333.jpg" alt="" class="wp-image-824141"/><figcaption class="wp-element-caption">Idao de Tillard och Clément Duvaldestin. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4 Hela 440 tvååringar har redan gått kvallopp i Frankrike i år på blott en månad. Snabbast i O-årgången (8.815 hästar) är en son till <strong>Idao de Tillard.</strong> <a href="https://sulkysport.se/tvaaring-kvalade-pa-1-156/" data-type="link" data-id="https://sulkysport.se/tvaaring-kvalade-pa-1-156/" target="_blank" rel="noreferrer noopener">Oswald Newport</a> noterade 1.15,6/2.000 meter i Caen när Frankrike öppnade säsongen för tvååringskval den 5 maj.</p>



<h2 class="wp-block-heading">Avelshingstar med tio eller fler kvalade tvååringar:</h2>



<p><strong>Far – Antal i kullen – Inkvalade</strong></p>



<ol class="wp-block-list">
<li><strong>Idao de Tillard </strong>– 81 – 20</li>



<li><strong>Italiano Vero</strong> – 83 – 16</li>



<li><strong>Face Time Bourbon</strong> – 87 – 13</li>



<li><strong>In the Money </strong>– 66 – 11</li>



<li><strong>Just A Gigolo</strong> – 71 – 10</li>
</ol>



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



<p class="has-drop-cap">5 Pocono Downs bjöd på kvallopp för tvååringar igår och Åke Svanstedt gjorde i det närmaste rent hus och hade den snabbaste vinnaren i stoet <strong>Kountry Plunge</strong> (e. Chapter Seven-Plunge Blue Chip), vilken kom hem på 1.14,4/1.609 meter för Sarah Svanstedt.</p>



<p>Det toppstammade stoet ägs bland annat av Åke Svanstedt, Midnigh Sun, Bender Sweden och Ecurie Diocles. Som ettåring köptes hon för 200.000 dollar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260610kl.18.31.43-617x355.jpg" alt="" class="wp-image-860692"/><figcaption class="wp-element-caption">Gabriela Beatriz vinner enkelt för Åke Svanstedt.</figcaption></figure>



<p>Vann gjorde Åke Svanstedt med svenskfödda <strong>Gabriela Beatriz </strong>(e. Walner-Milady Grace) på 1.15,0 efter 1.11,6 sista 400 meterna. Stoet ägs av sin uppfödare Ecurie Diocles och Kjell Johansson. Vinstmarginalen blev fem längder.</p>



<p>Modern och Breeders Crown-vinnaren <strong>Milady Grace</strong> (e. Ready Cash), 1.12,2am*/3.468.000 kr, har en avkomma sedan tidigare och i måndags kvalade treårige valacken <strong>Fabio Fognini</strong> (e. Walner) på 1.16,8/2.140 meter för Björn Goop.</p>



<h2 class="wp-block-heading">Här är de tvååriga kvalvinnarna:</h2>



<p><strong>Namn (kön/stamtavla) – Segertid</strong></p>



<ul class="wp-block-list">
<li><strong>Kountry Plunge</strong> (s e. Chapter Seven-Plunge Blue Chip) – 1.14,4</li>



<li><strong>Dandelion </strong>(s e. Ecurie D.K.-Plum Wine) – 1.14,5</li>



<li><strong>Red Storm Hanover </strong>( h e. Captain Corey-Ready Any Time) –1.14,5</li>



<li><strong>Gabriela Beatriz </strong>(s e. Walner-Milady Grace) – 1.15,0</li>



<li><strong>Queen Palema</strong> (s e. Walner-Sobti Hanover) på 1.15,6</li>



<li><strong>Lincoln Kronos</strong> (h e. Walner-Chatty Kronos) – 1.16,0</li>
</ul>



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



<p class="has-drop-cap">6 Efter andraplatsen i Gran Premio della Lotteria i Neapel i början av maj har Sébastien Guarato bestämt sig för att ge <strong>Frank Gio </strong>(e. Face Time Bourbon), 1.09,4ak/€1.138.589, en tävlingspaus, vilket betyder att han står över Prix René Ballière den 21 juni på Vincennes.</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>– Vi har låtit honom koppla av efter Lotterian. Just nu joggar han bara och återupptar det ordinarie arbetet nästa vecka, berättar Sébastian Guarato för Paris-Turf.</p>



<p>Anledningen är att Gurato anser att hästen behövt en återhämtningsperiod efter den intensiva inledningen på säsongen och nästa mål är Grand Prix de Wallonie (€150.000) i Mons den 19 september.</p>



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



<p class="has-drop-cap">7 <strong>Ålborg</strong> (första start kl. 15.45) bjuder på två penningstinna löpningar med danska mått mätt på fredag och det handlar om Grand Circle 5-års Championat både för danskfödda hingstar/valacker och ston. I båda loppen väntar 122.500 danska kronor till vinnaren, eller drygt 180.000 i svensk valuta.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/06/stefanpersson-617x333.jpg" alt="" class="wp-image-732835"/><figcaption class="wp-element-caption">Stefan Persson åker till Ålborg på fredag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Men det betyder inte att det finns svenskintresse. Stefan Persson åker till Ålborg för att köra en duo från Magnus Ladegaards stall. I hingstarna och valackernas uppgörelse sitter han bakom <strong>King Legend </strong>(e. Victor Gio) och han ställs emot en av kulltopparna <strong>Kungfufighting</strong> (e. Nuncio) och Jan Dahlgaard.</p>



<p><strong>Kash Shadow</strong> (e. Wicker Hanover) möter <strong>Kaley D.C. </strong>(e. Wishing Stone) och hon har överlägsna meriter i loppet, men inlett året med blygsamma placeringar. Ifjol vann Kaley D.C. bland annat Jydsk 4-årings Grand Prix, danska Stosprintern och slutade tvåa i Stoderbyt.</p>



<h2 class="wp-block-heading">Startlistor:</h2>



<p><strong>Grand Circle 5-års Championat</strong><br>Femåriga hingstar/valacker.<br><strong>Förstapris: </strong>122.500 dkk.<br><em>2.140 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Kesse Tårs</strong> (e. Donato Hanover) – Knud Mönster</li>



<li><strong>Kalles Krisbe Notz </strong>(e. Executive Caviar) – Bent Svendsen</li>



<li><strong>Kungfufighting </strong>(e. Nuncio) – Jan Dahlgaard</li>



<li><strong>King Legend </strong>(e. Victor Gio) – Stefan Persson</li>



<li><strong>Kingston Flamingo </strong>(e. Ens Snapshot) – Anders Pedersen</li>



<li><strong>Kal El </strong>(e. Googoo Gaagaa) – Morten Friis</li>



<li><strong>Koogoo Gaagaa </strong>(e. Googoo Gaagaa) – Nicklas Korfitsen</li>



<li><strong>Kingston West</strong> (e. Lindy Lane) – Birger Jörgensen</li>



<li><strong>Kombardo Skov</strong> (e. Dominion Beach) – Patrick Larsen</li>



<li><strong>Klinton</strong> (e. Varenne) – Jeppe Juel</li>
</ol>



<p><strong>Grand Circle 5-års Championat</strong><br>Femåriga ston.<br><strong>Förstapris: </strong>122.500 dkk.<br><em>2.140 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Kisser Vang </strong>(e. Googoo Gaagaa) – Kasper Foget</li>



<li><strong>Kimibi Kini </strong>(e. Great Challenger) – Nicklas Korfitsen</li>



<li><strong>Kryds Ved Stöjberg</strong> (e. Hillustrious) – Morten Friis</li>



<li><strong>Karoline Gardenia</strong> (e. Great Challenger) – Birger Jörgensen</li>



<li><strong>Kaley D.C.</strong> (e. Wishing Stone) – Henrik Lönborg</li>



<li><strong>Komsålangborg</strong> (e. Hillustrious) – Knud Mönster</li>



<li><strong>Kirsten Tinghöj</strong> (e. Dominion Beach) – Jeppe Juel</li>



<li><strong>Kandis Spring </strong>(e. Fourth Dimension) – Jeppe Rask</li>



<li><strong>Kash Shadow </strong>(e. Wicker Hanover) – Stefan Persson</li>



<li><strong>Kylie By Hans </strong>(e. Googoo Gaagaa) – Patrick Larsen</li>



<li><strong>Karisma Gardenia</strong> (e. Dominion Beach) – Jan Dahlgaard</li>



<li><strong>Kohinoor </strong>(e. From Above) – Bent Svendsen</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Ny Redén-trippel i Visby?
Stefan Persson i dubbla danska storlopp. Dags för vinst för Mellby Jinxs baneman? Summer-meeting-kval. Lotteria-tvåa vilar till hösten. Så många tvååringar har kvalat i Frankrike. Kvalshow av Svanstedt i USA.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
