• >
  • >
  • PHOTOS - X Factor 2010 : quel serait pour vous le jury idéal parmi ces personnalités ?

PHOTOS - X Factor 2010 : quel serait pour vous le jury idéal parmi ces personnalités ?

14/10/2010 - 19h03
  • 7
Voir toutes les photos (37)Toutes les photos (37)
  • Sheryfa Luna Michael Jones Natacha Atlas Leslie Benoît Poher (du groupe Kyo) Julie Pietri Larusso Herbert Leonard Santi Jeanne Mas Khaled Louisy Joseph M. Pokora Ahmed Mouici (du groupe Pow Wow et des Dix Commandements) Féfé Lionel Florence Joyce Jonathan Jasmine Roy
  • Ophélie Winter Jean-Claude Camus Charlelie Couture Pascal Nègre Maïdi Roth Koxie Alice Donna Shy'm Patrick Hernandez Kenza Farah Plastic Bertrand Faudel Axel Bauer Gilbert Coullier Enzo Enzo Gilbert Montagné Maxime Le Forestier Arielle Dombasle
  • Matthieu Gonet
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • PHNwYW4gaWQ9InBob3RvXzI2MTY4MjYiPgoKICAgIAogICAgCiAgICAgICAgCiAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAoKICAgICAgICAgICAgICAgIDxpbWcgc3JjPSJodHRwOi8vY2RuLXByZW1pZXJlLmxhZG1lZGlhLmZyL3Zhci9wcmVtaWVyZS9zdG9yYWdlL2ltYWdlcy90ZWxlL25ld3MtcGhvdG9zL3Bob3Rvcy14LWZhY3Rvci0yMDEwLXF1ZWwtc2VyYWl0LXBvdXItdm91cy1sZS1qdXJ5LWlkZWFsLXBhcm1pLWNlcy1wZXJzb25uYWxpdGVzL3BhdHJpY2staGVybmFuZGV6LzM2ODgyODg3LTEtZnJlLUZSL1BhdHJpY2stSGVybmFuZGV6X3BvcnRyYWl0X3c4NTguanBnIiB3aWR0aD0iODU4IiBoZWlnaHQ9IjEyODciICBzdHlsZT0iYm9yZGVyOiAwcHggIDsiIGFsdD0iUGF0cmljayBIZXJuYW5kZXoiIHRpdGxlPSJQYXRyaWNrIEhlcm5hbmRleiIgICAvPgogICAgICAgICAgICAKICAgIAogICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxlbT4mY29weTsgVklTVUFMPC9lbT48L3NwYW4+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3Ryb25nPjxzcGFuPlBhdHJpY2sgSGVybmFuZGV6PC9zcGFuPjwvc3Ryb25nPiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c3BhbiBjbGFzcz0iZGlhcG9fZGVzY3JpcHRpb25faXRlbSI+PHA+PGI+TGUgMiBub3ZlbWJyZSBkw6ltYXJyZW50IGxlcyA8YSBocmVmPSJodHRwOi8vdGVsZS5wcmVtaWVyZS5mci9OZXdzLVRlbGUvWC1GYWN0b3ItTTYtcmVwcmVuZC1sZS10ZWxlLWNyb2NoZXQtZGUtVzktZXQtbGFuY2UtbGUtY2FzdGluZy0yNDIzODM2IiB0YXJnZXQ9Il9zZWxmIj5jYXN0aW5nczwvYT4gZHUgdMOpbMOpLWNyb2NoZXQgPGk+PGEgaHJlZj0iaHR0cDovL3RlbGUucHJlbWllcmUuZnIvWC1GYWN0b3ItMTg0OTQ2OSIgdGFyZ2V0PSJfc2VsZiI+WCBGYWN0b3I8L2E+PC9pPi4gTTYgbidhIGRvbmMgcGx1cyBxdWUgMyBzZW1haW5lcyBwb3VyIHNlIGTDqWNpZGVyIHN1ciBsZSBqdXJ5IHF1aSBjb21wb3NlcmEgc29uIMOpbWlzc2lvbi4gUGFybWkgY2VzIDM4IHBlcnNvbm5hbGl0w6lzLCBxdWVsbGVzIHNvbnQgbGVzIDMgcXVlIHZvdXMgdmVycmlleiBiaWVuIMOgIGNlIHBvc3RlIMOgIGxhIHBsYWNlIGRlIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9KdWxpZS1aZW5hdHRpLTIwNDA0MTciIHRhcmdldD0iX3NlbGYiPkp1bGllIFplbmF0dGk8L2E+LCA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvTWFyYy1DZXJyb25lLTEyNDk5OTQiIHRhcmdldD0iX3NlbGYiPk1hcmMgQ2Vycm9uZTwvYT4gZXQgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL0FsYWluLUxhbnR5LTIwNDA0MTgiIHRhcmdldD0iX3NlbGYiPkFsYWluIExhbnR5PC9hPiA/IFZvdGV6IGdyw6JjZSDDoCBub3RyZSBkaWFwb3JhbWEgdm90ZSAhPC9iPjwvcD48cD5BbG9ycyBxdWUgZGFucyAzIHNlbWFpbmVzIGTDqW1hcnJlbnQgbGVzIGNhc3RpbmdzIGRlIGxhIDJlIHNhaXNvbiBkZSA8aT48Yj5YIEZhY3RvcjwvYj48L2k+IHN1ciA8Yj5NNjwvYj4sIGxlcyBwcmVtacOocmVzIHJ1bWV1cnMgc3VyIGxhIGNvbXBvc2l0aW9uIGR1IDxiPm5vdXZlYXUganVyeTwvYj4gZHUgdMOpbMOpLWNyb2NoZXQgdG91cm5lbnQgc3VyIGxhIHRvaWxlLjwvcD48cD5RdWkgdmEgZG9uYyByZW1wbGFjZXIgPGEgaHJlZj0iaHR0cDovL3RlbGUucHJlbWllcmUuZnIvTmV3cy1UZWxlL1gtRmFjdG9yLU1hcmMtQ2Vycm9uZS1ldC1BbGFpbi1MYW50eS1yZWpvaWduZW50LUp1bGllLVplbmF0dGktZGFucy1sZS1qdXJ5LTE5Nzk5NjciIHRhcmdldD0iX3NlbGYiPkp1bGllIFplbmF0dGksIE1hcmMgQ2Vycm9uZSBldCBBbGFpbiBMYW50eSwgcHJlbWllcnMgw6AgYXZvaXIgdGVzdMOpIGxlIHLDtGxlIGRlIGp1csOpcyBldCBjb2FjaHM8L2E+IHBvdXI8Yj4gVzk8L2I+IGwnaGl2ZXIgZGVybmllciA/PC9wPjxwPkxhIHLDqWRhY3Rpb24gZGUgPGk+PGI+UHJlbWllcmUuZnI8L2I+PC9pPiBzJ2VzdCBhbXVzw6llIMOgIHRyb3V2ZXIgdW5lIHBldGl0ZSBxdWFyYW50YWluZSBkZSBjYW5kaWRhdHMgcG90ZW50aWVscyDDoCBjZSBwb3N0ZS48L3A+PHA+UGFybWkgZXV4LCBkZXMgcHJvZHVjdGV1cnMgY29tbWUgSmVhbi1DbGF1ZGUgQ2FtdXMgb3UgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL1Bhc2NhbC1OZWdyZSIgdGFyZ2V0PSJfc2VsZiI+UGFzY2FsIE7DqGdyZTwvYT4sIG1haXMgYXVzc2kgZGVzIGNoYW50ZXVycyBldCBwYXJvbGllcnMgY29tbWUgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL01heGltZS1MRS1GT1JFU1RJRVItMzYwNTg0IiB0YXJnZXQ9Il9zZWxmIj5NYXhpbWUgTGUgRm9yZXN0aWVyPC9hPiwgPGEgaHJlZj0iaHR0cDovL3d3dy5wcmVtaWVyZS5mci9TdGFyL0F4ZWwtQmF1ZXItMTAzNDA1MiIgdGFyZ2V0PSJfc2VsZiI+QXhlbCBCYXVlcjwvYT4sIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9GYXVkZWwtMTAyODQ4IiB0YXJnZXQ9Il9zZWxmIj5GYXVkZWw8L2E+LCA8YSBocmVmPSJodHRwOi8vcGVvcGxlLnByZW1pZXJlLmZyL05ld3MtUGVvcGxlL0VYQ0xVLUxlc2xpZS1sYS1jaGFudGV1c2UtZGUtMjUtYW5zLWNvbmZpZS1KLWFpLXBldXItZGUtcmVub3Vlci11bi1kaWFsb2d1ZS1hdmVjLW1vbi1wZXJlLTIzMDkyNTUiIHRhcmdldD0iX3NlbGYiPkxlc2xpZTwvYT4sIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9BcmllbGxlLURvbWJhc2xlLTgwMTIxIiB0YXJnZXQ9Il9zZWxmIj5BcmllbGxlIERvbWJhc2xlPC9hPiBvdSA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvSm95Y2UtSm9uYXRoYW4tMjIyMzkzOCIgdGFyZ2V0PSJfc2VsZiI+Sm95Y2UgSm9uYXRoYW48L2E+LCBwb3VyIG5lIGNpdGVyIHF1J2V1eC48L3A+PHA+RMOpY291dnJleiBsZXMgPGI+MzggcGVyc29ubmFsaXTDqXM8L2I+IHF1ZSBub3VzIHZlcnJpb25zIGJpZW4gZGFucyA8aT48Yj5YIEZhY3RvcjwvYj48L2k+LCBsZSBjb25jb3VycyBkZSBjaGFudCBxdWkgcmVtcGxhY2VyYSA8aT48YSBocmVmPSJodHRwOi8vdGVsZS5wcmVtaWVyZS5mci9Ob3V2ZWxsZS1TdGFyLTE3MDUwMzQiIHRhcmdldD0iX3NlbGYiPkxhIE5vdXZlbGxlIFN0YXI8L2E+IDwvaT5jZXR0ZSBzYWlzb24uIE91dmVydCDDoCB1bmUgcGx1cyBsYXJnZSBwYWxldHRlIGRlIGNhbmRpZGF0cyAoMTYgw6AgOTkgYW5zLCBlbiBzb2xvLCBlbiBkdW8gb3UgZW4gZ3JvdXBlKSwgY2UgdMOpbMOpLWNyb2NoZXQgY3LDqcOpIHBhciA8YSBocmVmPSJodHRwOi8vd3d3LnByZW1pZXJlLmZyL1N0YXIvU2ltb24tQ293ZWxsLTgxNDAxIiB0YXJnZXQ9Il9zZWxmIj5TaW1vbiBDb3dlbGw8L2E+IGZhaXQgZnVyZXVyIMOgIGwnw6l0cmFuZ2VyLjwvcD48cD5Wb3RleiBlbnN1aXRlIHBvdXIgdm9zIGZhdm9yaXMgcGFybWkgY2V0dGUgbGlzdGUuLi4gQ2hlcmNoZXogYmllbiwgaWwgeSBlbiBhIGZvcmPDqW1lbnQgZG9udCB2b3VzIGFpbWVyaWV6IHZvaXIgbGUgY29tZSBiYWNrIHN1ciA8Yj5NNjwvYj4sIMOgIGwnaW5zdGFyIGRlIDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9MaW8tMTAzODc3IiB0YXJnZXQ9Il9zZWxmIj5MaW88L2E+IG91IDxhIGhyZWY9Imh0dHA6Ly93d3cucHJlbWllcmUuZnIvU3Rhci9NYXJjby1QcmluY2UtODA4NTEiIHRhcmdldD0iX3NlbGYiPk1hcmNvIFByaW5jZTwvYT4gITwvcD48cD48Yj48YSBocmVmPSJodHRwOi8vdGVsZS5wcmVtaWVyZS5mci9YLUZhY3Rvci9YLUZhY3Rvci1Wb3Rlei1wb3VyLXZvdHJlLWp1cnktaWRlYWwtIiB0aXRsZT0iVm90ZXogcG91ciB2b3RyZSBqdXLDqSBJZMOpYWwgZGUgWCBGYWN0b3IgISIgdGFyZ2V0PSJfYmxhbmsiPiZndDsgVm90ZXogaWNpIHBvdXIgdm90cmUganVyw6kgZGUgWCBGYWN0b3IgaWTDqWFsICE8L2E+PC9iPjwvcD48L3NwYW4+
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
Toutes les photos (37)Toutes les photos (37)
En savoir plus
X Factor
X Factor
You can dance : l'émission côté coulisses
You can dance : l'émission côté coulisses
VIDEO - The Voice : l'émission débarque en Grand-Bretagne
VIDEO - The Voice : l'émission débarque en Grand-Bretagne
Dream with me : une nouvelle série lancée à la rentrée pour NRJ 12 ?
Dream with me : une nouvelle série lancée à la rentrée...
The X Factor US : Janet Jackson en négociations pour faire partie du jury
The X Factor US : Janet Jackson en négociations pour faire...
PHOTOS - Télé crochet : le jury idéal de Premiere.fr
PHOTOS - Télé crochet : le jury idéal de Premiere.fr
Whitney Houston : Simon Cowell voulait l’engager comme jurée d’X Factor
Whitney Houston : Simon Cowell voulait l’engager comme...
Les derniers diaporamas photos télé
COMMENTAIRES
7
Connectez-vous en cliquant ici pour laisser un commentaire en utilisant votre pseudo. Si vous ne vous loguez pas, votre commentaire n'apparaîtra qu'en ANONYME.
Afficher les messages :
"AnonymeJeanne Mas: The Queen of Has-beens !!!!!!!!!!!!!!!!!!!!!!!" Ah !!!! Jeanne Mas a vendu plus de 8 millions de disque, elle a été la première femme a faire Bercy, etc, elle remplit des scènes parisiennes tous les 2 ans sans promo et vient de sortir un album encensé par la critique, pas mal pour la reine des has been. elle habite aux USA dans un etrès grande proporiété, comme toi je suppose, je veux bien être has been comme elle dans ce cas. Sheryfa Luna, je n'ai rien contre elle, mais il faut arréter là, elle n'as pas 30 ans de métier comme la reine des has been selon vous Jeanne Mas :)
  • 0
  • 0
Anonyme | le 28/09/2011 à 16h41 | Signaler un abus
répondre
Votre réponse...
magalie vaé de retour!!!!
  • 0
  • 0
Anonyme | le 21/10/2010 à 20h45 | Signaler un abus
répondre
Votre réponse...
magalie vaé de retour!!!!
  • 0
  • 0
Anonyme | le 21/10/2010 à 20h43 | Signaler un abus
répondre
Votre réponse...
cyril cinélu!!!!!!!!!!!!!!!!!!!!!
  • 0
  • 0
Anonyme | le 21/10/2010 à 20h42 | Signaler un abus
répondre
Votre réponse...
cyril cinélu!!!!!!!!!!!!!!!!!!!!!
  • 0
  • 0
Anonyme | le 21/10/2010 à 20h41 | Signaler un abus
répondre
Votre réponse...
Jeanne Mas: The Queen of Has-beens !!!!!!!!!!!!!!!!!!!!!!!
  • 0
  • 0
Anonyme | le 19/10/2010 à 14h09 | Signaler un abus
répondre
Votre réponse...
sheryfaaaaaaaaaaaaaaaa thye best!!!
  • 0
  • 0
Anonyme | le 18/10/2010 à 19h49 | Signaler un abus
répondre
Votre réponse...
HAUT
Les Tweets de Thierry Moreau
Programme TV avecTélé7
  • 20h50 Section de recherches 77
  • 20h35 Envoyé spécial 0
  • 20h40 A l'origine 777
  • 20h55 Desperate Housewives 3
  • 20h35 Les carnets de route de François Busnel
  • 20h50 Bones 77
  • 20h40 A l'origine 777
  • 20h45 Pater 777
  • 21h00 Eurovision 2012 0
  • 20h40 Alien, le huitième passager 7777
> Tout le programme TV
La vidéo du jour
  • Zapping hebdo N°14 : Michaël Youn haut perché
> Toutes les vidéos tv
La sélection Replay avecTV-replay
  • Code Lyoko Code Lyoko Retour dans le laboratoire d'Amazonie pour Kadic, Yumi, Ulrich, Odd et Jérém ...
  • Gym direct Gym direct Un cours de gym présenté par Sandrine Arcizet.
  • 360° - GÉO 360° - GÉO 360°-GÉO suit les premiers pas au monastère de Lohit, un petit garçon de 4 a ...
    > Tout TV-replay
    Audiences TV
    Audience télé du 22/05 (source : Médiamétrie)
    • 25.6% Dr House 7 122 000 téléspectateurs
    • 15.6% Le dindon 3 902 000 téléspectateurs
    • 11.2% Cauchemar en cuisine 3 029 000 téléspectateurs
    > Toutes les audiences TV
    Plus d'émissions
    A lire également