
<p>Snogarps Gård har fått två nykomlingar. <strong>Unmistakable</strong> (e. Walner-Explosive Lynn), 1.11,5/$18.224, har fått sin första avkomma. En hingst efter Bar Hopping. Mormor <strong>Explosive Lynn</strong> (e. Explosive Matter), 1.12,2/$10.000, ingår i samma syskonskara som <strong>Wild Honey </strong>(e. Cantab Hall), 1.08,9ak*/16.219.104 kr, och <strong>Why Not Lindy</strong> (e. Credit Winner), 1.11,5/$112.598.</p>



<p>Ostartade italienskan <strong>Dream Magic Bi</strong> (e. Ready Cash-Princess Grif) har fått en dotter efter Tactical Landing. Ett stoföl efter Tactical Landing fick hon också förra året.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/skarmavbild20230514kl.11.38.52-617x468.jpg" alt="" class="wp-image-443703"/><figcaption class="wp-element-caption">Dream Magic Bi med sin dotter efter Tactical Landing. Foto: privat</figcaption></figure>



<p>– Hon går till Walner, berättar Barbro Wihlborg.</p>



<p>Dream Magic Bi är undan <strong>Princess Grif </strong>(e. Varenne), 1.10,3/€915.560, som bland annat vann Gran Premio d’Europa, Gran Premio Tino Triossi, och Gran Premio delle Nazione. En startande avkomma har hon; <strong>Cover Girl </strong>(e. Muscle Hill), 1.13,8/€10.669. Själv ingår Dream Magic Bi i samma syskonskara som <strong>Martina Grif</strong> (e. Varenne), 1.12,3/€222.034.</p>



<h2 class="wp-block-heading">Nyfött i Grisslehamn</h2>



<p>Jens Ekstam och Jenny Hansen (J.J. Trotting, Grisslehamn) kan berätta om två nya föl. <strong>I Love Champagne</strong> (e. Love You-Champagne), 1.12,9ak/431.650 kr, har fått sin fjärde avkomma och det blev en dotter S.J.’s Caviar som far. Startat har fyraårige <strong>Keep Gamble </strong>(e. Cash Gamble), 1.17,1m*/61.500 kr, vilken har en seger på två starter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/ilovechampagne-617x757.jpg" alt="" class="wp-image-443705"/><figcaption class="wp-element-caption">I Love Champagnes dotter efter S.J.&#8217;s Caviar. Foto: privat</figcaption></figure>



<p>Modern I Love Champagne vann åtta lopp på 44 starter. Hon ingår i samma syskonskara som E3-vinnaren <strong>Policy of Truth</strong> (e. Explosive Matter), 1.09,6ak/5.911.400 kr.</p>



<p><strong>Madame Nicole</strong> (e. Gigant Neo-Little Nick), 1.11,6ak/743.948 kr, har fått ett sto efter Criterium Continental-vinnaren Eridan och det är den enda svenskfödda avkomman efter honom född 2023.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/madamenicolette-617x625.jpg" alt="" class="wp-image-443706"/><figcaption class="wp-element-caption">Madame Nicoles dotter efter Eridan. Foto: privat</figcaption></figure>



<p>Madame Nicole vann nio lopp på 76 starter innan hon gick till avel. En startande avkomma har Madame Nicole; <strong>Il Capitano</strong> (e. Brad de Veluwe), 1.13,2ak/239.210 kr.</p>



<p><strong>Rigel Anne</strong> (e. Bork Odin), 1.26,6k/234.995 kr, har fått sin första avkomma och hon nedkom med en dotter efter Roli Eld. Nästa partner blir Bellfaks och stoet ägs av Erika Gustafsson och Patric Berglund.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/rigelanne-617x856.jpg" alt="" class="wp-image-443707"/><figcaption class="wp-element-caption">Rigel Annes dotter efter Roli Eld. Foto: M Björnlund</figcaption></figure>



<p>Sju segrar på 50 starter tog Rigel Anne. Hon är undan ostartade <strong>Rigel Snerta </strong>(e. Metsgar), vilken också lämnat <strong>Rigel Odin </strong>(e. Moe Odin), 1.21,6ak/1.104.648 kr, <strong>Rigeljerven</strong> (e. Åsajerven), 1.24,5k/689.881 kr, och <strong>Rigel Öyvind </strong>(e. Dotterud Teddy), 1.23,8ak/484.697 kr.</p>



<h2 class="wp-block-heading">Två nykomlingar hos Dahlén</h2>



<p>Rebecca Dahlén kan också meddela två nya föl.<strong> Pippi </strong>(e. S.J.’s Photo), 1.10,9ak/908.362 kr, har fått en dotter efter Un Amour d’Haufor.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/pippi-617x823.jpeg" alt="" class="wp-image-443708"/><figcaption class="wp-element-caption">Pippis dotter efter Un Amour d&#8217;Haufor. Foto: privat</figcaption></figure>



<p>– Pippi betäcks om med Minnestads el Paso, berättar Rebecca Dahlén.</p>



<p>Pippi har tidigare lämnat <strong>Hurricane Gilbert </strong>(e. Trixton), 1.12,8ak/211.922 kr, och ingår i samma syskonskara som <strong>Dad’s Launcher</strong> (e. Gallant Baron), 1.13,2am/660.649 kr.</p>



<p>Ostartade <strong>Angel On Hold </strong>(e. Uncle Lasse-Simonette) har fått sin andra avkomma och blivit mor till ett sto efter Mister Hercules.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/angelonhold-617x827.jpeg" alt="" class="wp-image-443709"/><figcaption class="wp-element-caption">Angel On Hold med sin dotter efter Mister Hercules. Foto: privat</figcaption></figure>



<p>– Vi har inte bestämt oss i ombetäckningsfrågan, meddelar Rebecca.</p>



<p>Angel On Hold är undan<strong> Simonette</strong> (e. Alf Palema), 1.15,6am/169.450 kr, vilken är mor till <strong>Minnestads Ecuador </strong>(e. Chocolatier), 1.11,3am/329.500 kr, <strong>Minnestads Dubai</strong> (e. Ready Cash), 1.14,0al*/329.500 kr, och <strong>Speed Vici</strong> (e. Orlando Vici), 1.12,9ak/317.800 kr.</p>



<h2 class="wp-block-heading">Fem nya föl</h2>



<p>Madelen och Torbjörn Ohlzon kan berätta om fem nya föl på Långeruds Gård. <strong>Oblige Ås</strong> (e. Scarlet Knight-Noblesse Ås), 1.11,8ak/1.026.435 kr, har blivit mor till en hingst efter Googoo Gaagaa.</p>



<p>Av hennes tidigare avkommor ska <strong>Pokemon Ås </strong>(e. Kadabra), 1.11,8ak*/920.480 kr, och <strong>Orbital Ås</strong> (e. Conway Hall), 1.12,4ak/556.757 kr, nämnas i första hand.</p>



<p>Italienskfödda <strong>Trinidad As </strong>(e. Cantab Hall-Ima Quick), 1.12,0k/333.650 kr, har nedkommit med med en dotter efter Nuncio. En startande avkomma har hon sedan tidigare; <strong>Jimbaran Zon</strong> (e. Maharajah), 1.12,6ak/253.200 kr. Trinidad As är halvsyster med unghäststjärnan <strong>Quick Credit </strong>(e. Credit Winner-So Help Me), 1.11,7/$553.113, och <strong>Lawyer As</strong> (e. S.J.’s Photo), 1.12,1/€210.614.</p>



<h2 class="wp-block-heading">Första avkomman</h2>



<p><strong>Legendaria Zon</strong> (e. Muscle Hill-Dream of Joy), 1.13,8ak/202.300 kr, har fått sin första avkomma och det blev en dotter efter Maharajah. Modern startade 18 gånger (3-1-5) innan hon gick till avel. Hon är undan <strong>Dream of Joy</strong> (e. Dream Vacation),1.12,3ak/540.600 kr, viken har sin främsta avkomma i <strong>Nocturne Zon</strong> (e. Southwind Frank), 1.13,4am/459.500 kr.</p>



<p>Ostartade <strong>Darling U.M. </strong>(e. Cantab Hall-Flirtin My Way) har fått sin femte avkomma i Sverige, och en dotter efter Googoo Gaagaa. Båda hennes avkommor i startbar ålder har varit ute och tävlat och bäst har <strong>Ninja Zon</strong> (e. Uncle Lasse), 1.11,2ak/909.050 kr, lyckats.</p>



<h2 class="wp-block-heading">Halvsyster till O&#8217;Mara Zon</h2>



<p>En dotter har också <strong>Exclusive Zon</strong> (e.Varenne-Be A Gogo Girl), 1.11,8ak/587.250 kr, efter Readly Express. Det handlar om en halvsyster till <strong>O’Mara Zon</strong> (e. Maharajah), 1.11,8ak/1.710.000 kr, och <strong>Minnucci Zon</strong> (e. Trixton), 1.12,2ak/469.900 kr.</p>



<p>Ostartade mormor <strong>Be A Gogo Girl</strong> (e. Andover Hall) har sex svenskfödda avkommor och samtliga har tjänat över 100.000 kronor. Förutom Exclusive Zon har <strong>Gucci Zon</strong> (e. Celebrity Secret) nått över en halv miljon insprunget.</p>



<h2 class="wp-block-heading">Lämnat två miljonärer</h2>



<p>Lina Alm kan berätta att <strong>Zingy Kronos</strong> (e. Muscle Hill-Beauty America), 1.13,4am*/239.550 kr, har fått en dotter efter Ready Cash på Vomb.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/zingykronos-617x411.jpg" alt="" class="wp-image-443713"/><figcaption class="wp-element-caption">Zingy Kronos dotter efter Ready Cash. Foto: Lina Alm</figcaption></figure>



<p>– Hon går till Father Patrick i år, berättar Lina Alm.</p>



<p>Modern <strong>Beauty America</strong> (e. Pine Chip), 1.12,7ak/5.745.385 kr, har lämnat miljonärerna <strong>Lily Kronos </strong>(e. Varenne), 1.12,0ak/1.559.054 kr, och <strong>Vanquish Kronos </strong>(e. Raja Mirchi), 1.11,3ak/1.373.911 kr.</p>



<h2 class="wp-block-heading">Halvsyster med Axl Rose</h2>



<p>Stall Seabeach AB &#038; Stall Sefrema HB kan berätta att <strong>You Could Be Mine</strong> (e. Trixton-Linda di Casei), 1.12,4ak/504.700 kr, blivit mor för första gången. Hon har fått ett sto efter Calgary Games och går till Readly Express i år.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/youcouldbemine-617x823.jpg" alt="" class="wp-image-443714"/><figcaption class="wp-element-caption"><strong>You Could Be Mine</strong>s dotter efter Calgary Games. Foto: privat</figcaption></figure>



<p>You Could Be Mine startade 28 gånger och vann fem lopp. Hon är undan <strong>Linda di Casei </strong>(e. Uronometro), 1.10,3ak/€860.490, som firade stora framgångar och deltog i Prix d’Amerique hos Alessandro Gocciadoro. Stoets första avkomma <strong>Axl Rose </strong>(e. Love You), 1.11,3ak*/€581.471.</p>



<h2 class="wp-block-heading">Satsar på avelschansen</h2>



<p>Anita Adermalm kan berätta om två föl födda i Norge. <strong>Lax Faksa</strong> (e. Järvsöfaks), 1.30,5ak/65.594 kr, har fått en hingst efter Grisle Odin G.L. Modern har tidigare lagt trion <strong>Björlifant </strong>(e. Moe Odin), 1.22,9m/1.240.041 kr, <strong>Björlifanner </strong>(e. Tekno Odin), 1.22,4k/1.215.300 kr, och <strong>Björlifix </strong>(e. Tekno Odin), 1.25,9m*/356.100 kr.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/laxfaksamalfridvatne-617x617.webp" alt="" class="wp-image-443715"/><figcaption class="wp-element-caption">Lax Faksas hingst efter Grisle Odin G.L. Foto: Målfrid Vatne.</figcaption></figure>



<p>Lax Faksa är in sin tur halvsyster med <strong>Jubel Sture </strong>(e. Höiby Kongen), 1.23,9ak/1.222.650 kr, och <strong>Lax Vilja </strong>(e. Moe Odin), 1.31,4ak/91.100 kr, som är mor till <strong>Uggla I Mossen</strong> (e. Järvsöfaks), 1.24,2m/1.932.686 kr, och <strong>Buska Blyg</strong> (e. Järvsöviking), 1.22,4ak/1.163.500 kr.</p>



<p>Norska Derbytvåan <strong>Karmland Siv </strong>(e. Järvsöviking-Tangen Mi), 1.25,7am/414.657 kr, har också fått en hingst efter Grisle Odin G.L. Nästa partner blir Will Prinsen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/karmlandsiv-617x617.jpg" alt="" class="wp-image-443716"/><figcaption class="wp-element-caption">Karmland Sivs avkomma efter Grisle Odin G.L. Foto: Målfrid Vatne.</figcaption></figure>



<p>– Anledningen att vi är där är på grund av den nya avelschansen, berättar Anita Alderman.</p>



<h2 class="wp-block-heading">Dubbla föl hos Kolgjini</h2>



<p>Lufti Kolgjinis<strong> Ivana Cash</strong> (e. Ready Cash-Quietude Mesloise), 1.16,5m/69.900 kr, har fått en dotter efter Mosaique Face och går till Boccador de Simm.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/ivanacash-617x823.jpg" alt="" class="wp-image-443717"/><figcaption class="wp-element-caption">Ivana Cash med sin dotter efter Mosaique Face. Foto: privat</figcaption></figure>



<p>Mormor <strong>Quietude Mesloise</strong> (e. Look de Star), 1.12,6/€82.420, har sin främsta avkomma i <strong>Doberman</strong> (e. Prodigious), 1.12,1/€448.510.</p>



<p><strong>Racing Dreams </strong>(e. Kadabra-Armbro Mascara), 1.11,8/$95.785, har fått en hingst efter Raja Mirchi och nästa partner blir Mosaique Face. Två svenskdfödda avkommor har hon sedan tidigare efter Greenshoe och Tae Kwon Deo.</p>



<p>I USA fick hon fyra avkommor, varav två visat sig på tävlingsbanan; Cantab Hall-valackerna <strong>Thruway</strong>, 1.11,6/$140.115, och <strong>I Have A Dream,</strong> 1.11,5/$108.971. Mormor <strong>Armbro Mascara </strong>(e. Valley Victory), 1.10,2*/$100.903, har bland annat lämnat <strong>Garlands Dream</strong> ($189.671) och <strong>Another View</strong> ($155.190).</p>



<h2 class="wp-block-heading">Tre nyfödda på Västerbo Stuteri</h2>



<p>Tre föl kan Michael Demmers berätta om som fötts på Västerbo Stuteri. Tomas Wiklunds <strong>Ester Zonett </strong>(e. Pine Chip-Via de Vrie), 1.12,6ak/1.472.197 kr, har fått en dotter efter Mister J.P. och redan namngivits Majken Zonett. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/stofolemisterjpesterzonett-617x823.jpg" alt="" class="wp-image-443718"/><figcaption class="wp-element-caption">Ester Zonett med sitt sto efter Mister J.P. Foto: privat</figcaption></figure>



<p>Det är hennes sjunde avkomma och bäst har det gått för <strong>Klara Zonett</strong> (e. Maharajah), 1.13,2ak/419.900 kr, och <strong>Elsa Zonett </strong>(e. Pojke Kronos), 1.13,2ak*/200.200 kr.</p>



<p>Själv ingår Ester Zonett i samma syskonskara som <strong>Hilda Zonett</strong> (e. Spotlite Lobell), 1.10,5ak/15.434.377 kr, och <strong>Palmer Zonett</strong> (e. Lindy’s Crown), 1.12,0ak/1.602.126 kr.</p>



<p>– Ester Zonett återvänder till Mister J.P, berättar Michael Demmers.</p>



<p>Stall Upplands <strong>Hundredprocent Up </strong>(e. Coktail Jet-April Up), 1.12,5ak/457.800 kr, har fått sin första avkomma – en hingt efter Mister J.P.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/hemisterjphundredprocentup-617x823.jpg" alt="" class="wp-image-443720"/><figcaption class="wp-element-caption"><strong>Hundredprocent Up</strong> avkomma efter Mister J.P. Foto: privat</figcaption></figure>



<p>Mormor <strong>April Up</strong> (e. Rotation), 1.12,7ak/367.500 kr, har förutom Hundredprocent Up också lämnat <strong>Majestic Up </strong>(e. Maharajah), 1.11,6ak/310.500 kr.</p>



<p>Vidare har <strong>Runnerup</strong> (e. Alf Palema-Qoritika), 1.16,4am/109.500 kr, fått en dotter efter Un Amour d’Haufor och äger gör Peter Fritsdorf, Sollentuna. Nästa partner blir återigen Un Amour d’Haufor. En helsyster finns sedan tidigare till det nyfödda fölet; <strong>Miss Chevy Neo</strong>, 1.14,0ak/238.000 kr.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/stofolunamourdhaufour.runnerup-617x463.jpg" alt="" class="wp-image-443721"/><figcaption class="wp-element-caption">Runnerups dotter efter Un Amour d&#8217;Haufor. Foto: privat</figcaption></figure>



<p> 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>
