
<p class="has-drop-cap wp-block-paragraph">1 Idag avgörs världens äldsta Derby för travare. På Krieau-banan i Wien körs Österrikiskt Derby (€50.000) och den 138:e upplagan har lockat 16 hästar och från Sverige deltar två kuskar. Både Jorma Kontio och Jörgen Sjunnesson finns på plats i Wien och kör <strong>Power Conway</strong> (e. Conway Hall) respektive <strong>Abacco’s Prime</strong> (e. Alv Peacepipe).</p>



<p class="wp-block-paragraph">Wiens travbana Krieau invigdes den 29 september 1878 och sex år senare hölls det första Derbyt. Österrike – i äktenskap med Ungern – var under några decennier den ledande travnationen i Europa, större än Frankrike och nästan lika betydelsefull som självaste stormakten Tyskland. Innan Prix d´Amérique hade sett dagens ljus ansågs Championship von Europa i Baden (1895-1913) vara den viktigaste löpningen i Europa för äldre travare tillsammans med Matadoren-Rennen i Berlin.</p>



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



<p class="wp-block-paragraph"><strong>Österrikiskt Derby</strong> (€50.000)<br>Fyraåringar:<br><strong>Priser:</strong> 25.000-12.500-6.250-3.125-2.000-1.125 euro.<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>Lady Cash As</strong> (e. Ready Cash) – Matthias Schambeck</li>



<li><strong>M Eck Enroe</strong> (e. Odessa Santana) – Christoph Schwarz</li>



<li><strong>Jackpot</strong> (e. Russel November) – Hubert Brandsätter</li>



<li><strong>Mon Bijou RS </strong>(e. Light Kronos) – Franz Konlechner</li>



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



<li><strong>Power Conway </strong>(e. Conway Hall) – Jorma Kontio</li>



<li><strong>Agip</strong> (e. Eilean Donon) – Harald Sykora</li>



<li><strong>Giovanni Venus</strong> (e. Incredible Hulk) – Wolfgang Ruth</li>



<li><strong>Antonia O</strong> (e. Light Kronos) – Johan Buijs</li>



<li><strong>Massimo Venus</strong> (e. Celebration XL) – Ilona Kubikova</li>



<li><strong>Lea Venus</strong> (e. Light Kronos) – Carsten Milek</li>



<li><strong>Abacco’s Prime</strong> (e. Alv Peacepipe) – Jörgen Sjunnesson</li>



<li><strong>Makya</strong> (e. For Pleasure As) – Christoph Fischer</li>



<li><strong>Look at Me</strong> (e. Tiger Woods As) – Erich Kubes</li>



<li><strong>Kiwi’s Sixth Sense</strong> (e. Southwind Frank) – Gerhard Mayr</li>



<li><strong>Schneller Blitz L</strong> (e. Shaham Hall) – Matthias Walcher</li>
</ol>



<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/2021/09/uncletoll-617x289.jpg" alt="" class="wp-image-218100"/><figcaption class="wp-element-caption">Uncle Töll och Tova Bengtsson vid seger på Solvalla Kriteriehelgen 2021. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Vem är bäst i sulky <em>OCH</em> sadel? Dubbelkampen i <strong>Vaggeryd</strong> (första start 13.45) ger en fingervisning. Sedan 2017 har tolv ryttare/kuskar mötts i ett lopp i vardera disciplinen för att kora den bäste. Tova Bengtsson vann tre av de fyra första åren och lade beslag på första vandringspriset. Ett nytt sådant är ordnat och där har Henriette Larsen och just Tova varsin inteckning.</p>



<p class="wp-block-paragraph">Båda finns också med bland de tolv kvinnor som gör upp i årets upplaga av dubbelkampen.<br><strong>Deltagare är: </strong>Tova Bengtsson, Jenny Brunzell, Elinor Digerstedt, Linnea Djupdahl, Hilda Eskilsson, Christina A Hande, Henriette Larsen, Emilia Leo, Jennifer Persson, Emilie Sivertsson, Åsa Svensson och Alexandra Wisén.</p>



<p class="wp-block-paragraph">Ett lopp som sticker ut är annars ett dubbelklasslopp med STL-bekantingar som <strong>Farfars Dream</strong> (e. Maharajah), <strong>Lincoln Abe Boko</strong> (e. Trixton) och <strong>Wingait Henke</strong> (e. Maharajah) på startfållan och vassa stoet <strong>Olga Utca </strong>(e. Maharajah) jagande 20 meter bakom från start.</p>



<p class="wp-block-paragraph">Söndagen kompletteras med breddlopp på <strong>Umåker</strong> (start 14.00).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/230618.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Tvååringarna kvalade på Meadowlands igår och av de 36 anmälda var 33 tränade av svenskar och det blev blågult för hela slanten. Tre svenska tränare vann lopp och snabbast var Timo Nurmos-ägde <strong>Pantoran</strong> (e. Walner-Southwind Gilly) på 1.13,1/1.609 meter, vilken kördes till seger av Åke Svanstedt.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/09/timonurmoslangvagn-617x333.jpg" alt="" class="wp-image-357265"/><figcaption class="wp-element-caption">Timo Nurmos. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Ifjol köpte Nurmos Pantoran – då namngiven Southwind Graphite – på Lexington Selected Yearling Sale och hingsten gick loss för 110.000 dollar. Ostartade modern <strong>Southwind Gilly</strong> (e. Father Patrick) ingår i samma syskonskara som <strong>Southwind Coors</strong> ($234.960) och <strong>El Toro Loco </strong>($158.346), varav den förstnämnde finalvann <a href="https://sulkysport.se/favoritfall-i-kanada/" target="_blank" rel="noreferrer noopener">Goodtimes Stakes</a> (C$250.000) i natt på Mohawk Raceway.  </p>



<h2 class="wp-block-heading">Svenskfödda kvalvinnare:</h2>



<p class="wp-block-paragraph"><strong>Namn (kön, stamtavla) – Tränare – Vinnartid</strong></p>



<ul class="wp-block-list">
<li><strong>Pantoran</strong> (h e. Walner-Southwind Gilly) – Åke Svanstedt – 1.13,1</li>



<li><strong>The Moment </strong>(s e. Father Patrick-Myimpossibledream) – Lucas Wallin – 1.14,0</li>



<li><strong>Senorita Palema</strong> (s e. Chapter Seven-Tosca) – Åke Svanstedt – 1.14,4</li>



<li><strong>Slip Sliding Away</strong> (s e. Father Patrick-Ice Attraction) – Åke Svanstedt – 1.14,4</li>



<li><strong>Amazing Catch </strong>(h e. Walner-Mets Life) – Åke Svanstedt 1.14,7</li>



<li><strong>Dolce Amara </strong>(s e. Muscle Hill-Ciao Dolce) – Lucas Wallin – 1.15,5</li>



<li><strong>Security Protected</strong> (h e. Father Patrick-Thatsnotmyname) – Marcus Melander – 1.15,5</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">4En biljett till Jarlsbergs internationella storlopp Ulf Thoresen Grand International söndag 8 juli med 800.000 kronor till vinnaren står på spel vid kvällens tävlingar på Jarlsberg. Där körs ett uttagningslopp med 40.000 kronor till vinnaren och en plats i storloppet om tre veckor.<br>Frode Hamre är flitigast representerad med tre av sju hästar i startlistan, däribland sexfaldige franske miljonären <strong>Feydeau Seven</strong> (e. Redeo Josselyn).</p>



<p class="wp-block-paragraph"><strong>Startlista försök till Ulf Thoresen Grand International, uttagning</strong><br><em>1.609 meter autostart:</em></p>



<ol class="wp-block-list">
<li><strong>Vitro Diablo</strong> (e. Bold Eagle) – Tom Erik Solberg (Erik Killingmo)</li>



<li><strong>Park View</strong> (e. Self Possessed) – Vidar Hop (Erik Killingmo)</li>



<li><strong>Gigant Invalley</strong> (e. Gigant Neo) – Gunnar Austevoll (Truls Desserud)</li>



<li><strong>Type A.</strong> (e. Southwind Frank) – Lars Anvar Kolle (Frode Hamre)</li>



<li><strong>Sheena’s Boy </strong>(e. Trixton) – Eirik Höitomt (Kristian Malmin)</li>



<li><strong>Feydeau Seven </strong>(e. Redeo Josselyn) – Magnus Teien Gundersen (Frode Hamre)</li>



<li><strong>Hede Darling</strong> (e. Password) –  Frode Hamre</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5 Efter ett sju månader långt tävlingsuppehåll gör Tomas Malmqvist-tränade <strong>Koelho de Nappes</strong> (e. Charly du Noyer) comeback vid kvällens tävlingar i <strong>La Capelle</strong> (första start 17.07).</p>



<p class="wp-block-paragraph">Tvååringssäsongen innehöll fyra starter med en andra- samt en tredjeplats som bästa resultat och nu ska hingsten försöka bärga karriärens första fullträff i Prix de la Capelle (€23.000) över 2.750 meter voltstart där 10.350 euro väntar vinnaren.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Ostartade <strong>Auqua Post </strong>(e. Farifant-Voyance) har fått sin första avkomma och det blev en hingst efter Cash Okay på Västerbo Stuteri. Modern ägs av Mats Rundström och Västerbo Stuteri och Auqua Post återvänder till Cash Okay.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/skarmavbild20230617kl.08.49.49-617x653.jpg" alt="" class="wp-image-459200"/><figcaption class="wp-element-caption">Auqua Posts första avkomma föddes i fredags morse. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Auqua Post är undan italienskan <strong>Voyance</strong> (e. Buvetier d’Aunou), vilken har sin främsta avkomma i <strong>Fayence</strong> (e. Daguet Rapide), 1.12,0ak*/662.269 kr. Voyance är i sin tur undan Armbro Glamour (e. Super Bowl), vars mest känd avkomma är Elitlopps- och Prix d’Amérique-vinnaren <strong>Coktail Jet </strong>(e. Quoky Williams), 1.10,7ak/€1.896.774, som dessutom är flerfaldig championhingst.</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.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Travera höll auktion igår och dyrast blev fyraårige <strong>Reckless Tile</strong> (e. Walner-Never Ever Clever). 1.13,7ak/188.300 kr, och den enda travaren som klev upp i sexsiffrigt belopp. Ceorum AB betalade 280.000 kronor för hästen som startat 15 gånger och vunnit ett lopp i regi Ulf Stenströmer.</p>



<h2 class="wp-block-heading">Resultat Travera-auktionen:</h2>



<p class="wp-block-paragraph"><strong>Reckless Tile</strong> (valack 4 år e. Walner-Never Ever Clever)<br>Pris: 280.000 kr, Ceorum AB.</p>



<p class="wp-block-paragraph"><strong>Paparazzi Zon</strong> (valack 3 år e. Coin Perdu-Dream of Joy)<br>Pris: 95.000 kr, Ala-Rantalan Ravitalli.</p>



<p class="wp-block-paragraph"><strong>Global Twilight</strong> (fölsto 10 år e. Muscle Hill-Celebrity Tribute)<br>Pris: 65.000 kr, Anonym köpare.</p>



<p class="wp-block-paragraph"><strong>Endgame</strong> (sto 4 år e. Maharajah-Everreach Draviet)<br>Pris: 55.000 kr, Gunilla Melzén, Ruda.</p>



<p class="wp-block-paragraph"><strong>Monster Vinter</strong> (valack 3 år e. Åsajerven-Vertigo Vintra)<br>Pris: 50.000 kr, Ceorum AB.</p>



<p class="wp-block-paragraph"><strong>Zacapa U.S.</strong> (valack 6 år e. Father Patrick-Hollywood Hill)<br>Pris: 50.000 kr, Annamari Sipilä, Finland.</p>



<p class="wp-block-paragraph"><strong>Indian Spice</strong> (sto 5 år e. Raja Mirchi-Perfect Face)<br>Pris: 48.000 kr, Anonym köpare.</p>



<p class="wp-block-paragraph"><strong>Tekno Perla</strong> (sto 4 år e. Tekno Odin-Sundbo Perla)<br>Pris: 44.000 kr, Kajsa Lind, Moliden.</p>



<p class="wp-block-paragraph"><strong>T. Wall’s Kastor</strong> (valack 6 år e. Brad de Veluwe-Maxi Kimberley)<br>Pris: 42.000 kr, OKB Stable AB.</p>



<p class="wp-block-paragraph"><strong>Maggio Pellini </strong>(sto 4 år e. El Mago Pellini-Anna Karin’s Girl)<br>Pris: 38.000 kr, Mattias Engberg, Grums.</p>



<p class="wp-block-paragraph"><strong>Bird Parker</strong> – betäckning<br>Pris: 32.000 kr, Anonym köpare.</p>



<p class="wp-block-paragraph"><strong>Global Diditmyself </strong>(valack 4 år e. Donato Hanover-Self Made Woman)<br>Pris: 32.000 kr, Sofie Carlberg, Rättvik.</p>



<p class="wp-block-paragraph"><strong>Hailey Rich</strong> (sto 4 år e. Alvena Pele-Rebecka Hill)<br>Pris: 28.000 kr, Tina Karlsson, Älvkarleby.</p>



<p class="wp-block-paragraph"><strong>Delight Dream</strong> (sto 2 år e. Crazed-Cantab Doll)<br>Pris: 24.000 kr, Stall Vega.</p>



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



<ul class="wp-block-list">
<li><strong>Cassiopea Font</strong> (sto 5 år e. Muscle Mass-Romanza Font) – 95.000 kr</li>



<li><strong>Hambo D.</strong> (fölsto 6 år e. Maharajah-Up Front Peg) – 50.000 kr</li>



<li><strong>Princess d’Fleur</strong> (sto 2 år e. Earl Simon-Pearl Princess) – 16.000 kr</li>



<li><strong>Flora Petes</strong> (sto 5 år e. Orecchietti-Blue Simone) – 12.000 kr</li>



<li><strong>Rut K.</strong> (fölsto 4 år e. Infinitif-Hilma K.) – 12.000 kr</li>
</ul>



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



<ul class="wp-block-list">
<li><strong>Simon Templar</strong> (valack 4 år e. Orecchietti-Namibia)</li>
</ul>
