
<p class="has-drop-cap wp-block-paragraph">1 I lördags svarade <strong>Borups Victory </strong>för en enastående avslutning som tvåa i Grupp I-loppet Seinäjoki-Race i Seinäjoki i Finland efter <strong>Mister Hercules</strong>. Daniel Wäjersten kastade loss från fjärde ytter på bortre långsidan. Sista 600 meterna avverkade Googoo Gaagaa-sonen på 1.07,9 och den avslutande kilometern klockades till 1.10,4.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/misterhercules2-617x411.jpg" alt="" class="wp-image-434267"/><figcaption class="wp-element-caption">Mister Hercules vinner Seinäjoki Race före utvändigt och duktigt spurtande Borups Victory i lördags. Photo: Elina Paavola</figcaption></figure>



<p class="wp-block-paragraph">– Ruggigt bra avslutning, men nu planerar jag att han ska få pusta lite. Sedan siktar vi in oss på Jubileumspokalen och så får vi se hur många starter det blir innan dess, säger Daniel Wäjersten.</p>



<p class="wp-block-paragraph">Borups Victory har hittat helt nya växlar sedan han kom till Wäjersten och på sju starter (4-2-1) har han tjänat nästan en miljon kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Den 21 december 1997 stannade ett av svensk travsports största hjärtan. Direkt efter målgång i ett lopp på Jägersro föll Kjell P Dahlström död ur sulkyn. En stor tränarprofil och hästkarl avled i en ålder av 69 år.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/inascotdef-617x333.jpg" alt="" class="wp-image-109509"/><figcaption class="wp-element-caption">Ina Scot, Helen A Johansson och Kjell P Dahlström. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Ikväll på gamla hemmabanan Mantorp hedras hans minne med femåringsloppet Kjell P Dahlströms Minne, som bjuder 150.000 kronor i förstapris.</p>



<p class="wp-block-paragraph">Kjell P Dahlström föddes den 14 december 1938 och växte upp ett stenkast från Solvalla. Travintresset fanns där redan i unga år, men Kjell P valde till en början en annan yrkesbana – som polis. När han arbetade i yrket i Boden började han träna hästar själv på amatörbasis. När han flyttade söderut igen på 1970-talet växte amatörverksamheten. Med Hassan Star som första stora stjärna tog Kjell P klivet till att bli proffstränare på Mantorp 1981.</p>



<p class="wp-block-paragraph">Champis Brunn, Hallon Brunn och Don Kiwin var andra travare som formades till topphästar i Kjell P Dahlströms regi, men ingen var som Ina Scot (e. Allen Hanover). Det långbenta stoet – ett av Sveriges bästa genom tiderna – vann det mesta från Kriteriet och Derbyt som unghäst till Oslo Grand Prix och framför allt Prix d’Amérique som äldre, då med Helen A Johansson i sulkyn.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Sju hästar slutet upp i Kjell P Dahlströms Minne och det låga deltagarantalet till trots håller loppet finfin klass. <strong>Iznogoud Am</strong> (e. Muscle Hill) var tvåa i både Sprintermästaren och Europaderyt förra året, <strong>Edibear</strong> (e. Make It Happen) var trea i Derbyt och <strong>Sourire Frö</strong> (e. Wishing Stone) tvåa i Breeders Crown för att nämna några.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/iznogoudam-617x333.jpg" alt="" class="wp-image-374523"/><figcaption class="wp-element-caption">Stefan P Pettersson-tränade Iznogoud Am vid seger i semifinalen i Breeders Crown förra året.. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Dessuom ligger nästan 2,5 miljoner kronor extra i sexrättspotten på V64 i kvällens omgång på Mantorptravet.</p>



<p class="wp-block-paragraph">Ytterligare två svenska banor tävlar idag. Först ut är <strong>Östersund</strong> (start 12.20) med lunchtävlingar, där Öystein Tjomland gästar med starka kort som hård betrodda <strong>Brageson</strong> (e. Lome Brage), <strong>Big Success</strong> (e. Father Patrick), <strong>Be Sober</strong> (e. Raja Mirchi) och Gran Eld (e. Lome Brage).</p>



<p class="wp-block-paragraph">Kvällen kompletteras med <strong>Färjestad</strong> (start 17.45).</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Alessandro Gocciadoro och <strong>Edy Girifalco Gio</strong> (e. Victor Gio-Muruoa As) hade lekstuga igår i Gran Premio Elwood Medium (€37.400) i Padova efter att duon attackerat i tredjespår på sista bortre långsidan. Edy Girifalco Gio tog sig fram utvändigt om ledande Elettra Bi i sista sväng och hade avgjort innan upploppet.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/img9110-350x263.jpg" alt="" class="wp-image-434563"/><figcaption class="wp-element-caption">Edy Girifalco Gio.</figcaption></figure>



<p class="wp-block-paragraph">Segertiden blev 1.13,5a/1.640 meter när treåringen tog sin femte seger i tionde starten. Etereo Jet (e. Igor Font) spurtade in som tvåa på 1.13,7, medan tredjeplatsen gick till Eland (e. Oreste) på 1.13,9.</p>



<p class="wp-block-paragraph">Edy Girifalco Gio tog sin största triumf, men har tidigare varit tvåa respektive trea i Gran Premio-löpningarna Anact respektive Mipaaf som tvååring. Som ettåring var Victor Gio-sonen utbjuden på ITS Yearling Sale och där gick han tillbaka för 14.000 euro.</p>



<p class="wp-block-paragraph">Modern <strong>Muruoa As </strong>(e. Lemon Dra), 1.11,4/€282.068, ingår i samma syskonskara som <strong>Andros Asm</strong> (e. S.J.’s Photo), 1.13,1/€249.745, <strong>Brigata Asm</strong> (e. S.J.’s Photo), 1.13,1/€121.987, <strong>Cerreto As</strong> (e. Crowning Classic), 1.12,5/€146.87, och <strong>Ebro As</strong> (e. S.J’s Photo), 1.14,3/€101.381.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Jörgen Westholm startar <strong>Made of Stars</strong> (e. Super Photo Kosmos) i sadelloppet Prix Maison de Quartier Chatllons (€25.000) över 2.550 meter i Reims idag. Till sin hjälp har han Alexandre Bodin. I samma löpning går två andra svenskfödda travare ut: <strong>Huis Clos</strong> (e. Bird Parker) och <strong>Myllkärs Medusa</strong> (e. The Bank).</p>



<p class="wp-block-paragraph">I Prix Axa Sonia Canneau (€21.000) tar Ron Kuiper ut Stall Escapades toppstammade <strong>Hit Money </strong>(e. Cristal Money), vilken körs av Jérémy Koubiche, vilken inleder med 25 meters tillägg och startar från distansen 2.575 meter. Hit Moneys mor är självaste <strong>Pearl Queen</strong> (e. Carpe Diem), 1.11,4/€1.366.130.</p>



<p class="wp-block-paragraph">Första start i Reims är klockan 16.28.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Finske Kriterie-vinnaren <strong>Corazon Combo</strong> (e. Express Duo), 1.11,0ak/€310.125, har inlett året i dur. I lördags vann Pekka Korpis unghäststjärna sitt andra raka lopp i år i Seinäjoki. Han gjorde jobbet från spets och vann före Cupido Combo (e. Nuncio) på 1.16,0a/2.100 meter efter 1.11,5 sista halvvarvet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/11/image-617x387.jpg" alt="" class="wp-image-236546"/><figcaption class="wp-element-caption">Corazon Combo och Pekka Korpi. Foto: Iita-Maria Ahtiainen/Suomen Hippos </figcaption></figure>



<p class="wp-block-paragraph">I vinnarcirkeln berättade Pekka Korpi lite om framtidsplanerna:</p>



<p class="wp-block-paragraph">– Derbyt är naturligtvis det viktigaste loppet i år, men Sprintermästaren i Halmstad är inte helt utesluten.</p>



<p class="wp-block-paragraph">Corazon Combo har inte bara vunnit Kriteriet i sitt hemland. Som tvååring tog han hem Finskt Breeders Crown och Hevosenomistaja-Pokal, medan treåringssäsongen innehöll vinster i Kolmivuotispokaali och Seppele-Ajo. Han hade också en andraplats i långa E3 och ett tredjepris i den korta upplagan på meritlistan.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Kjell O Eriksson kan meddela att <strong>Björlitira </strong>(e. Bork Odin-Lax Tora), 1.30,8ak/109.900 kr, har fått sin första avkomma. Hos Frasse Fransson har hon fått ett sto efter Monster Monsun. Ny hingst är inte bestämd.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/bjorlitira-350x581.jpg" alt="" class="wp-image-434282"/><figcaption class="wp-element-caption">Björlitiras sto efter Monster Monsun. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Mormor <strong>Lax Tora</strong> (e. Järvsöfaks), 1.28,3am/261.438 kr, har sin främsta avkomma i <strong>Björli Thor</strong> (e. Sjefen), 1.25,7ak/303.650 kr. Själv ingår hon i samma syskonskara som <strong>Björli Svarten</strong> (496.544 kr) och <strong>Lax Nora </strong>(195.376 kr).</p>



<p class="wp-block-paragraph">På Haras de Sou i Normandie har <strong>Unrestricted</strong> (e. Muscles Yankee-Drive Through), 1.10,6ak/3.155.630 kr, fått en hingst efter Greenshoe och det är hennes tredje avkomma.</p>



<p class="wp-block-paragraph">Unrestricted är undan <strong>Drive Through </strong>(e. Quito de Talonay), 1.15,2ak/168.356 kr, som också är mor till trion <strong>Inlines </strong>(e. Malabar Man), 1.13,0ak/842.500 kr, <strong>Nonstop</strong> (e. Striking Sahbra), 1.12,3ak*/655.800 kr, och<strong> License Plate</strong> (e. Malabar Man), 1.11,5ak/653.244 kr</p>



<p class="wp-block-paragraph">Ett sto efter Önas Prince och <strong>Chi Mearas</strong> (e. Raja Mirchi-Dance of Joy), 1.15,6m/78.600 kr, har sett dagens ljus hos Bo Jondahl i Danmark och döpts till Miss Princess Ride. Det är moderns fjärde avkomma, varav hennes förstfödda <strong>Financial Freedom </strong>(e. The Bank), 1.19,5m/3.000 kr, har startat en gång.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/missprincessride-617x544.jpg" alt="" class="wp-image-434284"/><figcaption class="wp-element-caption">Chi Mearas avkomma efter Önas Prince. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Chi Mearas är undan ostartade <strong>Dance of Joy </strong>(e. Malabar Man), vars främsta avkommor är <strong>Buzz Mearas</strong> (e. Dream Vacation), 1.09,7ak/2.576.790 kr, och <strong>Gazoline Mearas</strong> (e. Ready Cash), 1.11,2ak/1.378.726 kr. Dance of Joys mor <strong>Dream of Joy </strong>(e. Victory Dream), 1.12,7*/$826.601, vann Breeders Crown, Goldsmith Maid och Merrie Annabelle under Per Erikssons vingar.</p>



<p class="wp-block-paragraph">Hos Lena Martell på Gotland har <strong>L. Dees Roccy </strong>(e. Credit Winner-Uncommon Scents), 1.16,6ak, nedkommit med ett sto efter Readly Express. Äger gör Lena Martell och Stall Zeno.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/ldeesroccy-617x679.jpeg" alt="" class="wp-image-434285"/><figcaption class="wp-element-caption">L. DeesRoccys sto efter Readly Express. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Det USA-födda stoet är mor till Breeders Crown-tvåan och Kriterie-fyran <strong>Indy Rock</strong> (e. Readly Express), 1.10,9ak/2.372.445 kr, och <strong>Double O. Seven</strong> (e. Chapter Seven), 1.10,7ak*/343.500 kr.</p>



<p class="wp-block-paragraph">L. Dees Roccy är undan <strong>Uncommon Scents</strong> (e. Valley Victor), 1.10,1*/$137.400, vars främsta avkommor är <strong>Chocolate Xplosion</strong> ($198.366) och <strong>Uncommon Night</strong> ($192.880).</p>



<p class="wp-block-paragraph">En hingst efter Brillantissime har <strong>Balett Sund </strong>(e. Muscles Yankee-Kronprinsessa Sund), 1.12,6ak/705.000 kr, blivi mamma till och modern ägs av Eagra Trav och Golv AB.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/balettsund-350x467.jpeg" alt="" class="wp-image-434286"/><figcaption class="wp-element-caption">Balett Sunds avkomma efter Brillantissime. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">– I år går hon till Boccador de Simm, berättar Johan Hermansson.</p>



<p class="wp-block-paragraph">Balett Sund har åtta avkommor sedan tidigare och toppar gör duon <strong>Global Dancer</strong> (e. Carat Williams), 1.10,8ak*/1.014.500 kr, och <strong>Global Wishmeluck</strong> (e. S.J.’s Caviar), 1.12.2ak/692.340 kr.</p>



<p class="wp-block-paragraph">Mormor <strong>Kronprinsessa Sund</strong> (e. Sugarcane Hanover), 1.13,4ak/1.297.929 kr, blev även mor till duon <strong>Victory Sund</strong> (e. Supergill), 1.12,5ak/961.188 kr, och <strong>Eminent Sund</strong> (e. Credit Winner), 1.13,2ak*/545.029 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.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>
